leancheck 0.6.7 → 0.7.0

raw patch · 164 files changed

+35421/−313 lines, 164 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

- Test.LeanCheck.Function.CoListable: (\+:/) :: [[a]] -> [[a]] -> [[a]]

- Test.LeanCheck.Function.CoListable: alts0 :: [[a]] -> [[a]]

- Test.LeanCheck.Function.CoListable: alts1 :: CoListable a => [[b]] -> [[a -> b]]

- Test.LeanCheck.Function.CoListable: alts2 :: (CoListable a, CoListable b) => [[c]] -> [[a -> b -> c]]

- Test.LeanCheck.Function.CoListable: alts3 :: (CoListable a, CoListable b, CoListable c) => [[d]] -> [[a -> b -> c -> d]]

- Test.LeanCheck.Function.CoListable: ftiers :: (CoListable a, Listable b) => [[a -> b]]

- Test.LeanCheck.Function.CoListable: infixr 9 \+:/

- Test.LeanCheck.Function.CoListable: instance (Test.LeanCheck.Function.CoListable.CoListable a, Test.LeanCheck.Core.Listable b) => Test.LeanCheck.Core.Listable (a -> b)

- Test.LeanCheck.Function.FunListable: (\+:/) :: [[a]] -> [[a]] -> [[a]]

- Test.LeanCheck.Function.FunListable: class FunListable a where validResults x = not . invalidResults x invalidResults x = not . validResults x

- Test.LeanCheck.Function.FunListable: funtiers :: FunListable a => [[(Int, [b] -> (a -> b))]]

- Test.LeanCheck.Function.FunListable: infixr 9 \+:/

- Test.LeanCheck.Function.FunListable: instance (Test.LeanCheck.Function.FunListable.FunListable a, Test.LeanCheck.Core.Listable b) => Test.LeanCheck.Core.Listable (a -> b)

- Test.LeanCheck.Function.FunListable: instance (Test.LeanCheck.Function.FunListable.FunListable a, Test.LeanCheck.Function.FunListable.FunListable b) => Test.LeanCheck.Function.FunListable.FunListable (Data.Either.Either a b)

- Test.LeanCheck.Function.FunListable: instance Test.LeanCheck.Function.FunListable.FunListable ()

- Test.LeanCheck.Function.FunListable: instance Test.LeanCheck.Function.FunListable.FunListable GHC.Types.Bool

- Test.LeanCheck.Function.FunListable: instance Test.LeanCheck.Function.FunListable.FunListable GHC.Types.Int

- Test.LeanCheck.Function.FunListable: instance Test.LeanCheck.Function.FunListable.FunListable Test.LeanCheck.Utils.Types.Nat

- Test.LeanCheck.Function.FunListable: instance Test.LeanCheck.Function.FunListable.FunListable Test.LeanCheck.Utils.Types.Nat2

- Test.LeanCheck.Function.FunListable: instance Test.LeanCheck.Function.FunListable.FunListable Test.LeanCheck.Utils.Types.Nat3

- Test.LeanCheck.Function.FunListable: instance Test.LeanCheck.Function.FunListable.FunListable a => Test.LeanCheck.Function.FunListable.FunListable (GHC.Base.Maybe a)

- Test.LeanCheck.Function.FunListable: instance Test.LeanCheck.Function.FunListable.FunListable a => Test.LeanCheck.Function.FunListable.FunListable [a]

- Test.LeanCheck.Function.FunListable: invalidResults :: FunListable a => a -> [b] -> Bool

- Test.LeanCheck.Function.FunListable: sndArgTypeOf :: b -> (a -> b -> c) -> b

- Test.LeanCheck.Function.FunListable: toMatrix :: Int -> [a] -> [[a]]

- Test.LeanCheck.Function.FunListable: validResults :: FunListable a => a -> [b] -> Bool

- Test.LeanCheck.Function.ListsOfPairs: associations :: [a] -> [[b]] -> [[[(a, b)]]]

- Test.LeanCheck.Function.ListsOfPairs: functionPairs :: [[a]] -> [[b]] -> [[[(a, b)]]]

- Test.LeanCheck.Function.ListsOfPairs: instance (GHC.Classes.Eq a, Test.LeanCheck.Core.Listable a, Test.LeanCheck.Core.Listable b) => Test.LeanCheck.Core.Listable (a -> b)

- Test.LeanCheck.Function.Periodic: functions :: Eq b => [a] -> [[b]] -> [[[(a, b)]]]

- Test.LeanCheck.Function.Periodic: functionsz :: Eq b => [[a]] -> [[b]] -> [[[(a, b)]]]

- Test.LeanCheck.Function.Periodic: instance (GHC.Classes.Eq a, GHC.Classes.Eq b, Test.LeanCheck.Core.Listable a, Test.LeanCheck.Core.Listable b) => Test.LeanCheck.Core.Listable (a -> b)

- Test.LeanCheck.Function.Periodic: isPeriod :: Eq a => [a] -> Bool

- Test.LeanCheck.Function.Periodic: isPeriodOf :: Eq a => [a] -> [a] -> Bool

- Test.LeanCheck.Function.Periodic: lsPeriodsOf :: Eq a => [[a]] -> [[[a]]]

- Test.LeanCheck.Function.Periodic: lsPeriodsOfLimit :: Eq a => [b] -> [[a]] -> [[[a]]]

- Test.LeanCheck.Function.Periodic: pairsToFunction :: Eq a => [(a, b)] -> (a -> b)

- Test.LeanCheck.Function.Periodic: tiersOfLimit :: [b] -> [[a]] -> [[[a]]]

+ Test.LeanCheck.Derive: deriveList :: Name -> ExpQ

+ Test.LeanCheck.Derive: deriveTiers :: Name -> ExpQ

+ Test.LeanCheck.Function.Listable.CoListable: instance (Test.LeanCheck.Function.CoListable.CoListable a, Test.LeanCheck.Core.Listable b) => Test.LeanCheck.Core.Listable (a -> b)

+ Test.LeanCheck.Function.Listable.FunListable: (\+:/) :: [[a]] -> [[a]] -> [[a]]

+ Test.LeanCheck.Function.Listable.FunListable: class FunListable a where validResults x = not . invalidResults x invalidResults x = not . validResults x

+ Test.LeanCheck.Function.Listable.FunListable: funtiers :: FunListable a => [[(Int, [b] -> (a -> b))]]

+ Test.LeanCheck.Function.Listable.FunListable: infixr 9 \+:/

+ Test.LeanCheck.Function.Listable.FunListable: instance (Test.LeanCheck.Function.Listable.FunListable.FunListable a, Test.LeanCheck.Core.Listable b) => Test.LeanCheck.Core.Listable (a -> b)

+ Test.LeanCheck.Function.Listable.FunListable: instance (Test.LeanCheck.Function.Listable.FunListable.FunListable a, Test.LeanCheck.Function.Listable.FunListable.FunListable b) => Test.LeanCheck.Function.Listable.FunListable.FunListable (Data.Either.Either a b)

+ Test.LeanCheck.Function.Listable.FunListable: instance Test.LeanCheck.Function.Listable.FunListable.FunListable ()

+ Test.LeanCheck.Function.Listable.FunListable: instance Test.LeanCheck.Function.Listable.FunListable.FunListable GHC.Types.Bool

+ Test.LeanCheck.Function.Listable.FunListable: instance Test.LeanCheck.Function.Listable.FunListable.FunListable GHC.Types.Int

+ Test.LeanCheck.Function.Listable.FunListable: instance Test.LeanCheck.Function.Listable.FunListable.FunListable Test.LeanCheck.Utils.Types.Nat

+ Test.LeanCheck.Function.Listable.FunListable: instance Test.LeanCheck.Function.Listable.FunListable.FunListable Test.LeanCheck.Utils.Types.Nat2

+ Test.LeanCheck.Function.Listable.FunListable: instance Test.LeanCheck.Function.Listable.FunListable.FunListable Test.LeanCheck.Utils.Types.Nat3

+ Test.LeanCheck.Function.Listable.FunListable: instance Test.LeanCheck.Function.Listable.FunListable.FunListable a => Test.LeanCheck.Function.Listable.FunListable.FunListable (GHC.Base.Maybe a)

+ Test.LeanCheck.Function.Listable.FunListable: instance Test.LeanCheck.Function.Listable.FunListable.FunListable a => Test.LeanCheck.Function.Listable.FunListable.FunListable [a]

+ Test.LeanCheck.Function.Listable.FunListable: invalidResults :: FunListable a => a -> [b] -> Bool

+ Test.LeanCheck.Function.Listable.FunListable: sndArgTypeOf :: b -> (a -> b -> c) -> b

+ Test.LeanCheck.Function.Listable.FunListable: toMatrix :: Int -> [a] -> [[a]]

+ Test.LeanCheck.Function.Listable.FunListable: validResults :: FunListable a => a -> [b] -> Bool

+ Test.LeanCheck.Function.Listable.ListsOfPairs: instance (GHC.Classes.Eq a, Test.LeanCheck.Core.Listable a, Test.LeanCheck.Core.Listable b) => Test.LeanCheck.Core.Listable (a -> b)

+ Test.LeanCheck.Function.Listable.Mixed: instance (GHC.Classes.Eq a, Test.LeanCheck.Core.Listable a, Test.LeanCheck.Function.CoListable.CoListable a, Test.LeanCheck.Core.Listable b) => Test.LeanCheck.Core.Listable (a -> b)

+ Test.LeanCheck.Function.Listable.Periodic: functions :: Eq b => [a] -> [[b]] -> [[[(a, b)]]]

+ Test.LeanCheck.Function.Listable.Periodic: functionsz :: Eq b => [[a]] -> [[b]] -> [[[(a, b)]]]

+ Test.LeanCheck.Function.Listable.Periodic: instance (GHC.Classes.Eq a, GHC.Classes.Eq b, Test.LeanCheck.Core.Listable a, Test.LeanCheck.Core.Listable b) => Test.LeanCheck.Core.Listable (a -> b)

+ Test.LeanCheck.Function.Listable.Periodic: isPeriod :: Eq a => [a] -> Bool

+ Test.LeanCheck.Function.Listable.Periodic: isPeriodOf :: Eq a => [a] -> [a] -> Bool

+ Test.LeanCheck.Function.Listable.Periodic: lsPeriodsOf :: Eq a => [[a]] -> [[[a]]]

+ Test.LeanCheck.Function.Listable.Periodic: lsPeriodsOfLimit :: Eq a => [b] -> [[a]] -> [[[a]]]

+ Test.LeanCheck.Function.Listable.Periodic: pairsToFunction :: Eq a => [(a, b)] -> (a -> b)

+ Test.LeanCheck.Function.Listable.Periodic: tiersOfLimit :: [b] -> [[a]] -> [[[a]]]

+ Test.LeanCheck.Function.ListsOfPairs: (-->>) :: Eq a => [[a]] -> [[b]] -> [[a -> b]]

+ Test.LeanCheck.Function.ListsOfPairs: exceptionPairs :: [[a]] -> [[b]] -> [[[(a, b)]]]

+ Test.LeanCheck.Stats: classStats :: (Listable a, Show b) => Int -> (a -> b) -> IO ()

+ Test.LeanCheck.Stats: classStatsT :: (Listable a, Show b) => Int -> (a -> b) -> IO ()

+ Test.LeanCheck.Stats: classify :: Eq a => [a] -> [[a]]

+ Test.LeanCheck.Stats: classifyBy :: (a -> a -> Bool) -> [a] -> [[a]]

+ Test.LeanCheck.Stats: classifyOn :: Eq b => (a -> b) -> [a] -> [[a]]

+ Test.LeanCheck.Stats: conditionStats :: Listable a => Int -> [(String, a -> Bool)] -> IO ()

+ Test.LeanCheck.Stats: conditionStatsT :: Listable a => Int -> [(String, a -> Bool)] -> IO ()

+ Test.LeanCheck.Stats: counts :: Eq a => [a] -> [(a, Int)]

+ Test.LeanCheck.Stats: countsBy :: (a -> a -> Bool) -> [a] -> [(a, Int)]

+ Test.LeanCheck.Stats: countsOn :: Eq b => (a -> b) -> [a] -> [(b, Int)]

Files

.gitignore +46/−0
.travis.yml +72/−0
Makefile +300/−0
TODO.md +21/−58
bench/tiers.hs +153/−0
eg/higher-order.hs +20/−0
eg/overflow.hs +52/−0
eg/test-bool.hs +19/−0
eg/test-list.hs +13/−0
eg/test-sort.hs +30/−0
leancheck.cabal +63/−7
mk/All.hs +14/−0
mk/Toplibs.hs +7/−0
mk/depend.mk +590/−0
mk/ghcdeps +49/−0
mk/haddock-i +24/−0
mk/haskell.mk +65/−0
src/Test/LeanCheck/Derive.hs +15/−6
src/Test/LeanCheck/Function.hs +1/−19
src/Test/LeanCheck/Function/CoListable.hs +6/−8
src/Test/LeanCheck/Function/FunListable.hs +0/−133
src/Test/LeanCheck/Function/Listable.hs +34/−0
src/Test/LeanCheck/Function/Listable/CoListable.hs +21/−0
src/Test/LeanCheck/Function/Listable/FunListable.hs +133/−0
src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs +21/−0
src/Test/LeanCheck/Function/Listable/Mixed.hs +20/−0
src/Test/LeanCheck/Function/Listable/Periodic.hs +57/−0
src/Test/LeanCheck/Function/ListsOfPairs.hs +13/−19
src/Test/LeanCheck/Function/Periodic.hs +0/−57
src/Test/LeanCheck/IO.hs +5/−5
src/Test/LeanCheck/Stats.hs +126/−0
src/Test/LeanCheck/Utils.hs +2/−0
stack.yaml +15/−0
tests/diff/eg/higher-order.out +50/−0
tests/diff/eg/overflow.out +2/−0
tests/diff/eg/test-bool.out +29/−0
tests/diff/eg/test-list.out +6/−0
tests/diff/eg/test-sort.out +4/−0
tests/diff/tiers-BagBool.out +100/−0
tests/diff/tiers-BagNat.out +216/−0
tests/diff/tiers-BagNat2.out +63/−0
tests/diff/tiers-BagNat3.out +104/−0
tests/diff/tiers-BagU.out +23/−0
tests/diff/tiers-Bool.out +13/−0
tests/diff/tiers-Bools.out +79/−0
tests/diff/tiers-Char.out +23/−0
tests/diff/tiers-Int,Int,Int.out +72/−0
tests/diff/tiers-Int,Int.out +100/−0
tests/diff/tiers-Int.out +23/−0
tests/diff/tiers-Integer.out +23/−0
tests/diff/tiers-Ints.out +47/−0
tests/diff/tiers-Nat,Nat,Nat.out +72/−0
tests/diff/tiers-Nat,Nat.out +100/−0
tests/diff/tiers-Nat.out +23/−0
tests/diff/tiers-Nats.out +47/−0
tests/diff/tiers-NoDupBool.out +17/−0
tests/diff/tiers-NoDupNat.out +226/−0
tests/diff/tiers-NoDupNat2.out +16/−0
tests/diff/tiers-NoDupNat3.out +30/−0
tests/diff/tiers-NoDupU.out +12/−0
tests/diff/tiers-SetBool.out +15/−0
tests/diff/tiers-SetNat.out +75/−0
tests/diff/tiers-SetNat2.out +14/−0
tests/diff/tiers-SetNat3.out +19/−0
tests/diff/tiers-SetU.out +12/−0
tests/diff/tiers-String.out +47/−0
tests/diff/tiers-U,Us.out +23/−0
tests/diff/tiers-Us,Us.out +100/−0
tests/diff/tiers-Us.out +23/−0
tests/diff/tiers-colistable-Bool-Bool.out +23/−0
tests/diff/tiers-colistable-Bool-MBool.out +40/−0
tests/diff/tiers-colistable-Bool-U.out +14/−0
tests/diff/tiers-colistable-Bools-Bools.out +745/−0
tests/diff/tiers-colistable-Int-Int-Int.out +625/−0
tests/diff/tiers-colistable-Int-Int.out +2637/−0
tests/diff/tiers-colistable-Ints-Ints.out +315/−0
tests/diff/tiers-colistable-MBool-Bool.out +43/−0
tests/diff/tiers-colistable-MBool-MBool.out +122/−0
tests/diff/tiers-colistable-Nat,Nat-Nat.out +625/−0
tests/diff/tiers-colistable-Nat-Nat-Nat.out +625/−0
tests/diff/tiers-colistable-Nat-Nat.out +2637/−0
tests/diff/tiers-colistable-Nat-U.out +667/−0
tests/diff/tiers-colistable-Nat2-Nat2.out +25/−0
tests/diff/tiers-colistable-Nat2-Nat3.out +42/−0
tests/diff/tiers-colistable-Nat3-Nat2.out +46/−0
tests/diff/tiers-colistable-Nat3-Nat3.out +125/−0
tests/diff/tiers-colistable-Nats-Nats.out +315/−0
tests/diff/tiers-colistable-U-Bool.out +15/−0
tests/diff/tiers-colistable-U-Nat.out +29/−0
tests/diff/tiers-colistable-U-U.out +13/−0
tests/diff/tiers-colistable-Us-Us.out +165/−0
tests/diff/tiers-funlistable-Bool-Bool.out +23/−0
tests/diff/tiers-funlistable-Bool-MBool.out +40/−0
tests/diff/tiers-funlistable-Bool-U.out +14/−0
tests/diff/tiers-funlistable-Bools-Bools.out +165/−0
tests/diff/tiers-funlistable-Int-Int-Int.out +10/−0
tests/diff/tiers-funlistable-Int-Int.out +10/−0
tests/diff/tiers-funlistable-Ints-Ints.out +95/−0
tests/diff/tiers-funlistable-MBool-Bool.out +43/−0
tests/diff/tiers-funlistable-MBool-MBool.out +122/−0
tests/diff/tiers-funlistable-Nat,Nat-Nat.out +10/−0
tests/diff/tiers-funlistable-Nat-Nat-Nat.out +10/−0
tests/diff/tiers-funlistable-Nat-Nat.out +10/−0
tests/diff/tiers-funlistable-Nat-U.out +10/−0
tests/diff/tiers-funlistable-Nat2-Nat2.out +10/−0
tests/diff/tiers-funlistable-Nat2-Nat3.out +10/−0
tests/diff/tiers-funlistable-Nat3-Nat2.out +10/−0
tests/diff/tiers-funlistable-Nat3-Nat3.out +10/−0
tests/diff/tiers-funlistable-Nats-Nats.out +95/−0
tests/diff/tiers-funlistable-U-Bool.out +15/−0
tests/diff/tiers-funlistable-U-Nat.out +29/−0
tests/diff/tiers-funlistable-U-U.out +13/−0
tests/diff/tiers-funlistable-Us-Us.out +55/−0
tests/diff/tiers-listsofpairs-Bool-Bool.out +23/−0
tests/diff/tiers-listsofpairs-Bool-MBool.out +40/−0
tests/diff/tiers-listsofpairs-Bool-U.out +14/−0
tests/diff/tiers-listsofpairs-Bools-Bools.out +385/−0
tests/diff/tiers-listsofpairs-Int-Int-Int.out +215/−0
tests/diff/tiers-listsofpairs-Int-Int.out +377/−0
tests/diff/tiers-listsofpairs-Ints-Ints.out +175/−0
tests/diff/tiers-listsofpairs-MBool-Bool.out +43/−0
tests/diff/tiers-listsofpairs-MBool-MBool.out +122/−0
tests/diff/tiers-listsofpairs-Nat,Nat-Nat.out +135/−0
tests/diff/tiers-listsofpairs-Nat-Nat-Nat.out +215/−0
tests/diff/tiers-listsofpairs-Nat-Nat.out +377/−0
tests/diff/tiers-listsofpairs-Nat-U.out +27/−0
tests/diff/tiers-listsofpairs-Nat2-Nat2.out +25/−0
tests/diff/tiers-listsofpairs-Nat2-Nat3.out +42/−0
tests/diff/tiers-listsofpairs-Nat3-Nat2.out +46/−0
tests/diff/tiers-listsofpairs-Nat3-Nat3.out +125/−0
tests/diff/tiers-listsofpairs-Nats-Nats.out +175/−0
tests/diff/tiers-listsofpairs-U-Bool.out +15/−0
tests/diff/tiers-listsofpairs-U-Nat.out +29/−0
tests/diff/tiers-listsofpairs-U-U.out +13/−0
tests/diff/tiers-listsofpairs-Us-Us.out +115/−0
tests/diff/tiers-mixed-Bool-Bool.out +35/−0
tests/diff/tiers-mixed-Bool-MBool.out +67/−0
tests/diff/tiers-mixed-Bool-U.out +17/−0
tests/diff/tiers-mixed-Bools-Bools.out +1115/−0
tests/diff/tiers-mixed-Int-Int-Int.out +3625/−0
tests/diff/tiers-mixed-Int-Int.out +2997/−0
tests/diff/tiers-mixed-Ints-Ints.out +475/−0
tests/diff/tiers-mixed-MBool-Bool.out +75/−0
tests/diff/tiers-mixed-MBool-MBool.out +230/−0
tests/diff/tiers-mixed-Nat,Nat-Nat.out +745/−0
tests/diff/tiers-mixed-Nat-Nat-Nat.out +3625/−0
tests/diff/tiers-mixed-Nat-Nat.out +2997/−0
tests/diff/tiers-mixed-Nat-U.out +677/−0
tests/diff/tiers-mixed-Nat2-Nat2.out +37/−0
tests/diff/tiers-mixed-Nat2-Nat3.out +69/−0
tests/diff/tiers-mixed-Nat3-Nat2.out +78/−0
tests/diff/tiers-mixed-Nat3-Nat3.out +233/−0
tests/diff/tiers-mixed-Nats-Nats.out +475/−0
tests/diff/tiers-mixed-U-Bool.out +19/−0
tests/diff/tiers-mixed-U-Nat.out +41/−0
tests/diff/tiers-mixed-U-U.out +15/−0
tests/diff/tiers-mixed-Us-Us.out +265/−0
tests/diff/tiers.out +10/−0
tests/test-derive.hs +14/−1
tests/test-fun.hs +29/−0
tests/test-funshow.hs +80/−0
tests/test-io.hs +10/−0
tests/test-sdist +31/−0
tests/test-stats.hs +45/−0

+ .gitignore view

@@ -0,0 +1,46 @@+.cabal-sandbox+cabal.sandbox.config+.stack-work+idx/+dist/+log/+*.swp+*.swo+*.swn+*.swm+*.o+*.hi+*.dyn_hi+*.dyn_o+tests/test+tests/test-derive+tests/test-error+tests/test-fun+tests/test-funshow+tests/test-io+tests/test-most+tests/test-operators+tests/test-tiers+tests/test-types+tests/test-stats+bench/tiers+bench/tiers-colistable+bench/tiers-colistable.hs+bench/tiers-listsofpairs+bench/tiers-listsofpairs.hs+bench/tiers-funlistable+bench/tiers-funlistable.hs+bench/tiers-mixed+bench/tiers-mixed.hs+eg/test-sort+eg/test-bool+eg/test-list+eg/higher-order+eg/overflow+doc/*.html+doc/*.css+doc/*.js+doc/*.png+doc/*.gif+mk/toplibs+README.html

+ .travis.yml view

@@ -0,0 +1,72 @@+# .travis.yml file for LeanCheck++language: c  # not really++notifications:+  email:+    on_failure: change++sudo: false++cache:+  directories:+  - $HOME/.ghc+  - $HOME/.cabal+  - $HOME/.stack++before_install:+- export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH+- ghc --version+- cabal --version+# Download and unpack the stack executable+# "Once Travis whitelists the stack.dev files," simply include stack in the+# addons section. -- https://docs.haskellstack.org/en/stable/travis_ci/+- mkdir -p ~/.local/bin+- export PATH=$HOME/.local/bin:$PATH+- travis_retry curl -L https://www.stackage.org/stack/linux-x86_64 | tar xz --wildcards --strip-components=1 -C ~/.local/bin '*/stack'+- stack config set system-ghc --global true+- stack --version++script:+- make && make test && make haddock HADDOCKFLAGS=+- cabal test+- stack --no-terminal --skip-ghc-check test++matrix:+  include:+  - ghc: 'head'+    env:                   GHCVER=head         CABALVER=head+    addons: {apt: {packages: [ghc-head,   cabal-install-head], sources: hvr-ghc}}+  - ghc: '8.2'+    env:                   GHCVER=8.2.1        CABALVER=2.0+    addons: {apt: {packages: [ghc-8.2.1,  cabal-install-2.0],  sources: hvr-ghc}}+  - ghc: '8.0'+    env:                   GHCVER=8.0.2        CABALVER=1.24+    addons: {apt: {packages: [ghc-8.0.2,  cabal-install-1.24], sources: hvr-ghc}}+  - ghc: '7.10'+    env:                   GHCVER=7.10.3       CABALVER=1.22+    addons: {apt: {packages: [ghc-7.10.3, cabal-install-1.22], sources: hvr-ghc}}+  - ghc: '7.8'+    env:                   GHCVER=7.8.4        CABALVER=1.18+    addons: {apt: {packages: [ghc-7.8.4,  cabal-install-1.18], sources: hvr-ghc}}+  # stack is only supported on GHC >= 7.8+  - ghc: '7.6'+    env:                   GHCVER=7.6.3        CABALVER=1.18+    addons: {apt: {packages: [ghc-7.6.3,  cabal-install-1.18], sources: hvr-ghc}}+    before_install:+    - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH+    - ghc --version+    - cabal --version+    script:+    - make GHCFLAGS=-O2 && make test GHCFLAGS=-O2 && make haddock HADDOCKFLAGS=+    - cabal test+  - ghc: '7.4'+    env:                   GHCVER=7.4.2        CABALVER=1.18+    addons: {apt: {packages: [ghc-7.4.2,  cabal-install-1.18], sources: hvr-ghc}}+    before_install:+    - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH+    - ghc --version+    - cabal --version+    script:+    - make GHCFLAGS=-O2 && make test GHCFLAGS=-O2 && make haddock HADDOCKFLAGS=+    - cabal test

+ Makefile view

@@ -0,0 +1,300 @@+# Makefile for LeanCheck+#+# Copyright:   (c) 2015-2017 Rudy Matela+# License:     3-Clause BSD  (see the file LICENSE)+# Maintainer:  Rudy Matela <rudy@matela.com.br>+TESTS = tests/test           \+        tests/test-derive    \+        tests/test-error     \+        tests/test-fun       \+        tests/test-funshow   \+        tests/test-io        \+        tests/test-operators \+        tests/test-tiers     \+        tests/test-stats     \+        tests/test-types+EGS = \+	eg/overflow \+	eg/higher-order \+	eg/test-bool \+	eg/test-list \+	eg/test-sort+BENCHS = \+	bench/tiers-colistable \+	bench/tiers-funlistable \+	bench/tiers-listsofpairs \+	bench/tiers-mixed \+	bench/tiers+LISTHS   = find src mk -name \*.hs+LISTOBJS = $(LISTHS) | sed -e 's/.hs$$/.o/'+ALLHS    = $(shell $(LISTHS))+ALLOBJS  = $(shell $(LISTOBJS))+OBJS = src/Test/LeanCheck.o \+       src/Test/LeanCheck/Function.o \+       src/Test/LeanCheck/Error.o+GHCIMPORTDIRS = src:tests+# -dynamic is needed only for src/Test/LeanCheck/Derive.hs and tests/test-derive.hs+GHCFLAGS = -dynamic -O2+HADDOCKFLAGS = --no-print-missing-docs++all: $(OBJS)++all-all: $(ALLOBJS)++test: $(patsubst %,%.test,$(TESTS)) diff-test++diff-test: diff-test-tiers diff-test-funtiers $(patsubst %,%.diff-test,$(EGS))++update-diff-test: update-diff-test-tiers update-diff-test-funtiers $(patsubst %,%.update-diff-test,$(EGS))++%.test: %+	./$<++eg/%.diff-test: eg/%+	./$< | diff -rud tests/diff/$<.out -++eg/%.update-diff-test: eg/%+	./$< >           tests/diff/$<.out++clean: clean-hi-o clean-haddock+	rm -f bench/tiers-colistable.hs+	rm -f bench/tiers-listsofpairs.hs+	rm -f bench/tiers-funlistable+	rm -f bench/tiers-funlistable.hs+	rm -f $(TESTS) $(BENCHS) $(EGS) mk/toplibs++ghci: mk/All.ghci++install:+	@echo "use \`cabal install' instead"++list-hs:+	$(LISTHS)++list-objs:+	$(LISTOBJS)++test-sdist:+	./tests/test-sdist++test-via-stack:+	stack test++legacy-test: # needs ghc-8.0 .. ghc-7.8 installed as such+	make clean  &&  make test GHC=ghc-8.0  GHCFLAGS="-Werror -dynamic"+	make clean  &&  make test GHC=ghc-7.10 GHCFLAGS="-Werror -dynamic"+	make clean  &&  make test GHC=ghc-7.8  GHCFLAGS="-Werror -dynamic"+	make clean  &&  make test++legacy-test-via-cabal: # needs similarly named cabal wrappers+	cabal clean  &&  cabal-ghc-8.0  configure  &&  cabal-ghc-7.10 test+	cabal clean  &&  cabal-ghc-7.10 configure  &&  cabal-ghc-7.10 test+	cabal clean  &&  cabal-ghc-7.8  configure  &&  cabal-ghc-7.8  test+	cabal clean  &&  cabal test++hlint:+	hlint \+	  --ignore "Use import/export shortcut" \+	  --ignore "Redundant bracket" \+	  .++markdown:+	pandoc README.md -o README.html+	pandoc doc/tutorial.md -o doc/tutorial.html+	pandoc doc/data-invariant.md -o doc/data-invariant.html++haddock: doc/index.html++clean-haddock:+	rm -f doc/*.{html,css,js,png,gif} README.html++upload-haddock:+	@echo "use \`cabal upload -d' instead"+	@echo "(but 1st: cabal install --only-dependencies --enable-documentation)"+	@echo "(to just compile docs: cabal haddock --for-hackage)"+	@echo "(on Arch Linux, use: cabal haddock --for-hackage --haddock-options=--optghc=-dynamic)"++doc/index.html: $(ALLHS)+	./mk/haddock-i base template-haskell | xargs \+	haddock --html -odoc $(ALLHS) $(HADDOCKFLAGS) --title=leancheck+	@echo 'NOTE: please ensure that there are *only* 7'+	@echo '      undocumented functions on Test.LeanCheck'+	@echo '      as "OPTIONS_HADDOCK prune" is active'+	@echo '      to hide cons6...cons12'++# NOTE: (very hacky!) the following target allows parallel compilation (-jN) of+# eg and tests programs so long as they don't share dependencies _not_ stored+# in src/ and tests/.  Runnable binaries should depend on mk/toplibs instead of+# actual Haskell source files+mk/toplibs: mk/Toplibs.o+	touch mk/toplibs++include mk/haskell.mk++diff-test-tiers: bench/tiers+	# simple types+	./bench/tiers "()"               | diff -rud tests/diff/tiers.out             -+	./bench/tiers "Int"              | diff -rud tests/diff/tiers-Int.out         -+	./bench/tiers "Nat"              | diff -rud tests/diff/tiers-Nat.out         -+	./bench/tiers "Integer"          | diff -rud tests/diff/tiers-Integer.out     -+	./bench/tiers "Bool"             | diff -rud tests/diff/tiers-Bool.out        -+	./bench/tiers "Char"             | diff -rud tests/diff/tiers-Char.out        -+	# list s+	./bench/tiers "[()]"             | diff -rud tests/diff/tiers-Us.out          -+	./bench/tiers "[Int]"          6 | diff -rud tests/diff/tiers-Ints.out        -+	./bench/tiers "[Nat]"          6 | diff -rud tests/diff/tiers-Nats.out        -+	./bench/tiers "[Bool]"         6 | diff -rud tests/diff/tiers-Bools.out       -+	./bench/tiers "String"         6 | diff -rud tests/diff/tiers-String.out      -+	# pairs+	./bench/tiers "(Int,Int)"        | diff -rud tests/diff/tiers-Int,Int.out     -+	./bench/tiers "(Nat,Nat)"        | diff -rud tests/diff/tiers-Nat,Nat.out     -+	./bench/tiers "(Int,Int,Int)"  6 | diff -rud tests/diff/tiers-Int,Int,Int.out -+	./bench/tiers "(Nat,Nat,Nat)"  6 | diff -rud tests/diff/tiers-Nat,Nat,Nat.out -+	# lists & pairs+	./bench/tiers "[((),())]"        | diff -rud tests/diff/tiers-U,Us.out        -+	./bench/tiers "([()],[()])"      | diff -rud tests/diff/tiers-Us,Us.out       -+	# special lists+	./bench/tiers "Set Bool"         | diff -rud tests/diff/tiers-SetBool.out     -+	./bench/tiers "Set ()"           | diff -rud tests/diff/tiers-SetU.out        -+	./bench/tiers "Set Nat"          | diff -rud tests/diff/tiers-SetNat.out      -+	./bench/tiers "Set Nat2"         | diff -rud tests/diff/tiers-SetNat2.out     -+	./bench/tiers "Set Nat3"         | diff -rud tests/diff/tiers-SetNat3.out     -+	./bench/tiers "Bag Bool"         | diff -rud tests/diff/tiers-BagBool.out     -+	./bench/tiers "Bag ()"           | diff -rud tests/diff/tiers-BagU.out        -+	./bench/tiers "Bag Nat"          | diff -rud tests/diff/tiers-BagNat.out      -+	./bench/tiers "Bag Nat2"         | diff -rud tests/diff/tiers-BagNat2.out     -+	./bench/tiers "Bag Nat3"         | diff -rud tests/diff/tiers-BagNat3.out     -+	./bench/tiers "NoDup Bool"       | diff -rud tests/diff/tiers-NoDupBool.out   -+	./bench/tiers "NoDup ()"         | diff -rud tests/diff/tiers-NoDupU.out      -+	./bench/tiers "NoDup Nat"        | diff -rud tests/diff/tiers-NoDupNat.out    -+	./bench/tiers "NoDup Nat2"       | diff -rud tests/diff/tiers-NoDupNat2.out   -+	./bench/tiers "NoDup Nat3"       | diff -rud tests/diff/tiers-NoDupNat3.out   -++update-diff-test-tiers: bench/tiers+	# simple types+	./bench/tiers "()"               > tests/diff/tiers.out+	./bench/tiers "Int"              > tests/diff/tiers-Int.out+	./bench/tiers "Nat"              > tests/diff/tiers-Nat.out+	./bench/tiers "Integer"          > tests/diff/tiers-Integer.out+	./bench/tiers "Bool"             > tests/diff/tiers-Bool.out+	./bench/tiers "Char"             > tests/diff/tiers-Char.out+	# lists+	./bench/tiers "[()]"             > tests/diff/tiers-Us.out+	./bench/tiers "[Int]"          6 > tests/diff/tiers-Ints.out+	./bench/tiers "[Nat]"          6 > tests/diff/tiers-Nats.out+	./bench/tiers "[Bool]"         6 > tests/diff/tiers-Bools.out+	./bench/tiers "String"         6 > tests/diff/tiers-String.out+	# pairs+	./bench/tiers "(Int,Int)"        > tests/diff/tiers-Int,Int.out+	./bench/tiers "(Nat,Nat)"        > tests/diff/tiers-Nat,Nat.out+	./bench/tiers "(Int,Int,Int)"  6 > tests/diff/tiers-Int,Int,Int.out+	./bench/tiers "(Nat,Nat,Nat)"  6 > tests/diff/tiers-Nat,Nat,Nat.out+	# lists & pairs+	./bench/tiers "[((),())]"        > tests/diff/tiers-U,Us.out+	./bench/tiers "([()],[()])"      > tests/diff/tiers-Us,Us.out+	# special lists+	./bench/tiers "Set Bool"         > tests/diff/tiers-SetBool.out+	./bench/tiers "Set ()"           > tests/diff/tiers-SetU.out+	./bench/tiers "Set Nat"          > tests/diff/tiers-SetNat.out+	./bench/tiers "Set Nat2"         > tests/diff/tiers-SetNat2.out+	./bench/tiers "Set Nat3"         > tests/diff/tiers-SetNat3.out+	./bench/tiers "Bag Bool"         > tests/diff/tiers-BagBool.out+	./bench/tiers "Bag ()"           > tests/diff/tiers-BagU.out+	./bench/tiers "Bag Nat"          > tests/diff/tiers-BagNat.out+	./bench/tiers "Bag Nat2"         > tests/diff/tiers-BagNat2.out+	./bench/tiers "Bag Nat3"         > tests/diff/tiers-BagNat3.out+	./bench/tiers "NoDup Bool"       > tests/diff/tiers-NoDupBool.out+	./bench/tiers "NoDup ()"         > tests/diff/tiers-NoDupU.out+	./bench/tiers "NoDup Nat"        > tests/diff/tiers-NoDupNat.out+	./bench/tiers "NoDup Nat2"       > tests/diff/tiers-NoDupNat2.out+	./bench/tiers "NoDup Nat3"       > tests/diff/tiers-NoDupNat3.out++prepare-depend: bench/tiers-listsofpairs.hs \+                bench/tiers-colistable.hs \+                bench/tiers-funlistable.hs \+                bench/tiers-mixed.hs++TLF = "import\ Test.LeanCheck.Function"++bench/tiers-listsofpairs.hs: bench/tiers.hs+	sed -e "s/$(TLF)$$/$(TLF).Listable.ListsOfPairs\n$(TLF).Show/" $< > $@++bench/tiers-colistable.hs: bench/tiers.hs+	sed -e "s/$(TLF)$$/$(TLF).Listable.CoListable\n$(TLF).Show/" $< > $@++bench/tiers-funlistable.hs: bench/tiers.hs+	sed -e "s/$(TLF)$$/$(TLF).Listable.FunListable\n$(TLF).Show/" $< > $@++bench/tiers-mixed.hs: bench/tiers.hs+	sed -e "s/$(TLF)$$/$(TLF).Listable.Mixed\n$(TLF).Show/" $< > $@++bench/tiers-colistable:   bench/tiers-colistable.hs   src/Test/LeanCheck/Function/Listable/CoListable.hs++bench/tiers-listsofpairs: bench/tiers-listsofpairs.hs src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs++bench/tiers-funlistable:  bench/tiers-funlistable.hs  src/Test/LeanCheck/Function/Listable/FunListable.hs++bench/tiers-mixed:        bench/tiers-mixed.hs        src/Test/LeanCheck/Function/Listable/Mixed.hs++diff-test-funtiers: bench/tiers-listsofpairs.diff-test \+                    bench/tiers-funlistable.diff-test \+                    bench/tiers-colistable.diff-test \+                    bench/tiers-mixed.diff-test++update-diff-test-funtiers: bench/tiers-listsofpairs.update-diff-test \+                           bench/tiers-funlistable.update-diff-test \+                           bench/tiers-colistable.update-diff-test \+                           bench/tiers-mixed.update-diff-test++bench/tiers-%.diff-test: bench/tiers-%+	# functions+	$< "()->()"           | diff -rud tests/diff/tiers-$*-U-U.out         -+	$< "Bool->Bool"       | diff -rud tests/diff/tiers-$*-Bool-Bool.out   -+	$< "Bool->()"         | diff -rud tests/diff/tiers-$*-Bool-U.out      -+	$< "()->Bool"         | diff -rud tests/diff/tiers-$*-U-Bool.out      -+	$< "Int->Int"       6 | diff -rud tests/diff/tiers-$*-Int-Int.out     -+	$< "Nat->Nat"       6 | diff -rud tests/diff/tiers-$*-Nat-Nat.out     -+	$< "()->Nat"        6 | diff -rud tests/diff/tiers-$*-U-Nat.out       -+	$< "Nat->()"        6 | diff -rud tests/diff/tiers-$*-Nat-U.out       -+	$< "Int->Int->Int"  4 | diff -rud tests/diff/tiers-$*-Int-Int-Int.out -+	$< "Nat->Nat->Nat"  4 | diff -rud tests/diff/tiers-$*-Nat-Nat-Nat.out -+	$< "(Nat,Nat)->Nat" 4 | diff -rud tests/diff/tiers-$*-Nat,Nat-Nat.out -+	$< "Maybe Bool->Bool" | diff -rud tests/diff/tiers-$*-MBool-Bool.out  -+	$< "Bool->Maybe Bool" | diff -rud tests/diff/tiers-$*-Bool-MBool.out  -+	$< "Maybe Bool->Maybe Bool" | diff -rud tests/diff/tiers-$*-MBool-MBool.out -+	# functions of lists+	$< "[Bool]->[Bool]" 4 | diff -rud tests/diff/tiers-$*-Bools-Bools.out -+	$< "[Nat]->[Nat]"   4 | diff -rud tests/diff/tiers-$*-Nats-Nats.out   -+	$< "[Int]->[Int]"   4 | diff -rud tests/diff/tiers-$*-Ints-Ints.out   -+	# more functions+	$< "Nat2->Nat2"       | diff -rud tests/diff/tiers-$*-Nat2-Nat2.out   -+	$< "Nat2->Nat3"       | diff -rud tests/diff/tiers-$*-Nat2-Nat3.out   -+	$< "Nat3->Nat2"       | diff -rud tests/diff/tiers-$*-Nat3-Nat2.out   -+	$< "Nat3->Nat3"       | diff -rud tests/diff/tiers-$*-Nat3-Nat3.out   -++bench/tiers-%.update-diff-test: bench/tiers-%+	# functions+	$< "()->()"           > tests/diff/tiers-$*-U-U.out+	$< "Bool->Bool"       > tests/diff/tiers-$*-Bool-Bool.out+	$< "Bool->()"         > tests/diff/tiers-$*-Bool-U.out+	$< "()->Bool"         > tests/diff/tiers-$*-U-Bool.out+	$< "Int->Int"       6 > tests/diff/tiers-$*-Int-Int.out+	$< "Nat->Nat"       6 > tests/diff/tiers-$*-Nat-Nat.out+	$< "Nat->()"        6 > tests/diff/tiers-$*-Nat-U.out+	$< "()->Nat"        6 > tests/diff/tiers-$*-U-Nat.out+	$< "Int->Int->Int"  4 > tests/diff/tiers-$*-Int-Int-Int.out+	$< "Nat->Nat->Nat"  4 > tests/diff/tiers-$*-Nat-Nat-Nat.out+	$< "(Nat,Nat)->Nat" 4 > tests/diff/tiers-$*-Nat,Nat-Nat.out+	$< "Maybe Bool->Bool" > tests/diff/tiers-$*-MBool-Bool.out+	$< "Bool->Maybe Bool" > tests/diff/tiers-$*-Bool-MBool.out+	$< "Maybe Bool->Maybe Bool" > tests/diff/tiers-$*-MBool-MBool.out+	# functions of lists+	$< "[()]->[()]"     4 > tests/diff/tiers-$*-Us-Us.out+	$< "[Bool]->[Bool]" 4 > tests/diff/tiers-$*-Bools-Bools.out+	$< "[Nat]->[Nat]"   4 > tests/diff/tiers-$*-Nats-Nats.out+	$< "[Int]->[Int]"   4 > tests/diff/tiers-$*-Ints-Ints.out+	# more functions+	$< "Nat2->Nat2"       > tests/diff/tiers-$*-Nat2-Nat2.out+	$< "Nat2->Nat3"       > tests/diff/tiers-$*-Nat2-Nat3.out+	$< "Nat3->Nat2"       > tests/diff/tiers-$*-Nat3-Nat2.out+	$< "Nat3->Nat3"       > tests/diff/tiers-$*-Nat3-Nat3.out

TODO.md view

@@ -26,21 +26,23 @@ other improvements ------------------ -* On `bench/tiers`, print if the enumeration has repetitions-  (import `Function.Eq` for that)+* implement `classStatsT` and `conditionStatsT` -* Modularize the `Derive` module by implementing-  `deriveTiers` and `deriveList`. -* Port `discardLaterT`, `discardT` and `nubT` from Speculate here.-  See `fitspec/eg/alga` for details.+later+----- -* add `classify` function to measure distribution of data:-  something like:+* implement stub `Test.LeanCheck.Function.*` modules; -    classifyBy :: (a -> b) -> [a] -> [(b,a)]-	countsBy :: (a -> b) -> [a] -> [(b,Int)]+* somehow, improve the improve the enumeration of `Char`s: +   list = [ ['a'], ['b','c'], ['d','e','f'], ... ]+      ||| [ [' '], ['\n'] ]+      ||| [ ['0'], ['1'], ['2'], ...]+      ||| ...+     where+     ||| is something that interleaves tiers of different lists...+ * further improve showing of functions, indead of showing:      \p q -> case (p,q) of@@ -53,57 +55,18 @@      \p q -> case (p,q) of             (True,False)  -> True-			_             -> False+            _             -> False    Some thinking may have to be done for:      \x y -> case (x,y) of-	        (0,0) -> 0-			(0,1) -> 0-			(1,1) -> 1-			(1,0) -> 1-			(0,2) -> 0-			(1,1) -> 1-			(2,0) -> 1-			...+            (0,0) -> 0+            (0,1) -> 0+            (1,1) -> 1+            (1,0) -> 1+            (0,2) -> 0+            (1,1) -> 1+            (2,0) -> 1+            ...    Where: `const (const 1) ->/ [(1,const 0)]`.---* idea for restructuring Function modules (all under `Test.LeanCheck.Function`):--	Show                  -- exports just Show (a -> b)-	Listable              -- exports just Listable (a -> b), based on LoP--	Listable.ListsOfPairs -- exports just Listable (a -> b), based on LoP-	Listable.CoListable   -- exports just Listable (a -> b), based on CoL--	CoListable            -- exports just the CoListable typeclass-	ListsOfPairs          -- exports just the LoP auxiliary functions-	ShowFunction          -- exports just the ShowFunction typeclass--  This structure seems somehow more clear to me.  It also allows, in the future, adding:--	module Test.LeanCheck.Function.Listable.Mixed where-	import Test.LeanCheck.Function.CoListable   as CoL-	import Test.LeanCheck.Function.ListsOfPairs as LoP-	instance Listable (a -> b) where-	  tiers = LoP.functions tiers tiers \/ CoL.cotiers tiers--  so that the user gets an enumeration of functions with repetitions, but using-  a mixed strategy for generation of values.---later--------* implement stub `Test.LeanCheck.Function.*` modules;--* somehow, improve the improve the enumeration of `Char`s:--   list = [ ['a'], ['b','c'], ['d','e','f'], ... ]-      ||| [ [' '], ['\n'] ]-      ||| [ ['0'], ['1'], ['2'], ...]-      ||| ...-     where-     ||| is something that interleaves tiers of different lists...

+ bench/tiers.hs view

@@ -0,0 +1,153 @@+-- tiers.hs -- prints tiers of values up to a certain point+--+-- Copyright (c) 2015-2017 Rudy Matela.+-- Distributed under the 3-Clause BSD licence (see the file LICENSE).+import Test.LeanCheck+import Test.LeanCheck.Utils.Types+import Test.LeanCheck.Function+import Test.LeanCheck.Function.Eq+import Test.LeanCheck.Tiers (showTiers, finite)+import System.Environment+import Data.List (intercalate, nub)+import Data.Ratio ((%))++dropEmptyTiersTail :: [[a]] -> [[a]]+dropEmptyTiersTail ([]:[]:[]: []:[]:[]: _) = []+dropEmptyTiersTail (xs:xss) = xs:dropEmptyTiersTail xss+dropEmptyTiersTail []     = []++lengthT :: [[a]] -> Maybe Int+lengthT xss | finite xss' = Just . length $ concat xss'+            | otherwise   = Nothing+  where xss' = dropEmptyTiersTail xss++allUnique :: Eq a => [a] -> Bool+allUnique [] = True+allUnique (x:xs) = x `notElem` xs+                && allUnique (filter (/= x) xs)++countRepetitions :: Eq a => [a] -> Int+countRepetitions xs = length xs - length (nub xs)++ratioRepetitions :: Eq a => [a] -> Rational+ratioRepetitions [] = 0+ratioRepetitions xs = fromIntegral (countRepetitions xs) % fromIntegral (length xs)++showLengthT :: [[a]] -> String+showLengthT xss = case lengthT xss of+                    Nothing -> "Infinity"+                    Just x  -> show x++showDotsLongerThan :: Show a => Int -> [a] -> String+showDotsLongerThan n xs = "["+                       ++ intercalate "," (dotsLongerThan n $ map show xs)+                       ++ "]"+  where+  dotsLongerThan n xs = take n xs ++ ["..." | not . null $ drop n xs]++printTiers :: Show a => Int -> [[a]] -> IO ()+printTiers n = putStrLn . init . unlines . map ("  " ++) . lines . showTiers n++put :: (Show a, Eq a, Listable a) => String -> Int -> a -> IO ()+put t n a = do+  putStrLn $ "tiers :: [" ++ t ++ "]  ="+  printTiers n $ tiers `asTypeOf` [[a]]+  putStrLn $ ""+  putStrLn $ "map length (tiers :: [[ " ++ t ++ " ]])  =  "+          ++ showDotsLongerThan n (map length $ tiers `asTypeOf` [[a]])+  putStrLn $ ""+  putStrLn $ "length (list :: [ " ++ t ++ " ])  =  "+          ++ showLengthT (tiers `asTypeOf` [[a]])+  putStrLn $ ""+  putStrLn $ "allUnique (list :: [ " ++ t ++ " ])  =  "+          ++ show (allUnique . concat . take n $ tiers `asTypeOf` [[a]])+  putStrLn $ ""+  putStrLn $ "ratioRepetitions (list :: [ " ++ t ++ " ])  =  "+          ++ show (ratioRepetitions . concat . take n $ tiers `asTypeOf` [[a]])++u :: a+u = undefined++main :: IO ()+main = do+  as <- getArgs+  let (t,n) = case as of+                []    -> ("Int", 12)+                [t]   -> (t,     12)+                [t,n] -> (t, read n)+  case t of+    -- simple types+    "()"               -> put t n (u :: ()                   )+    "Int"              -> put t n (u :: Int                  )+    "Nat"              -> put t n (u :: Nat                  )+    "Integer"          -> put t n (u :: Integer              )+    "Bool"             -> put t n (u :: Bool                 )+    "Char"             -> put t n (u :: Char                 )+    -- lists+    "[()]"             -> put t n (u :: [()]                 )+    "[Int]"            -> put t n (u :: [Int]                )+    "[Nat]"            -> put t n (u :: [Nat]                )+    "[Integer]"        -> put t n (u :: [Integer]            )+    "[Bool]"           -> put t n (u :: [Bool]               )+    "[Char]"           -> put t n (u :: [Char]               )+    "String"           -> put t n (u :: String               )+    -- pairs+    "((),())"          -> put t n (u :: ((),())              )+    "(Int,Int)"        -> put t n (u :: (Int,Int)            )+    "(Nat,Nat)"        -> put t n (u :: (Nat,Nat)            )+    "(Bool,Bool)"      -> put t n (u :: (Bool,Bool)          )+    "(Bool,Int)"       -> put t n (u :: (Bool,Int)           )+    "(Int,Bool)"       -> put t n (u :: (Int,Bool)           )+    "(Int,Int,Int)"    -> put t n (u :: (Int,Int,Int)        )+    "(Nat,Nat,Nat)"    -> put t n (u :: (Nat,Nat,Nat)        )+    -- lists & pairs+    "[((),())]"        -> put t n (u :: [((),())]            )+    "([()],[()])"      -> put t n (u :: ([()],[()])          )+    "([Bool],[Bool])"  -> put t n (u :: ([Bool],[Bool])      )+    "([Int],[Int])"    -> put t n (u :: ([Int],[Int])        )+    -- functions+    "()->()"           -> put t n (u :: () -> ()             )+    "()->Bool"         -> put t n (u :: () -> Bool           )+    "Bool->()"         -> put t n (u :: Bool -> ()           )+    "Bool->Bool"       -> put t n (u :: Bool -> Bool         )+    "Bool->Bool->Bool" -> put t n (u :: Bool -> Bool -> Bool )+    "Int->Int"         -> put t n (u :: Int -> Int           )+    "Int->Int->Int"    -> put t n (u :: Int -> Int -> Int    )+    "()->Nat"          -> put t n (u :: () -> Nat            )+    "Nat->()"          -> put t n (u :: Nat -> ()            )+    "Nat->Nat"         -> put t n (u :: Nat -> Nat           )+    "Nat->Nat->Nat"    -> put t n (u :: Nat -> Nat -> Nat    )+    "(Nat,Nat)->Nat"   -> put t n (u :: (Nat,Nat) -> Nat     )+    "Bool->Maybe Bool" -> put t n (u :: Bool -> Maybe Bool   )+    "Maybe Bool->Bool" -> put t n (u :: Maybe Bool -> Bool   )+    "Maybe Bool->Maybe Bool" -> put t n (u :: Maybe Bool -> Maybe Bool)+    -- functions with lists+    "[()]->[()]"       -> put t n (u :: [()] -> [()]         )+    "[Bool]->[Bool]"   -> put t n (u :: [Bool] -> [Bool]     )+    "[Int]->[Int]"     -> put t n (u :: [Int] -> [Int]       )+    "[Nat]->[Nat]"     -> put t n (u :: [Nat] -> [Nat]       )+    -- more functions+    "Nat2->()"         -> put t n (u :: Nat2 -> ()           )+    "()->Nat2"         -> put t n (u :: () -> Nat2           )+    "Nat2->Nat2"       -> put t n (u :: Nat2 -> Nat2         )+    "Nat2->Nat3"       -> put t n (u :: Nat2 -> Nat3         )+    "Nat3->Nat2"       -> put t n (u :: Nat3 -> Nat2         )+    "Nat3->Nat3"       -> put t n (u :: Nat3 -> Nat3         )+    -- special lists+    "Set Bool"         -> put t n (u :: Set Bool             )+    "Set ()"           -> put t n (u :: Set ()               )+    "Set Nat"          -> put t n (u :: Set Nat              )+    "Set Nat2"         -> put t n (u :: Set Nat2             )+    "Set Nat3"         -> put t n (u :: Set Nat3             )+    "Bag Bool"         -> put t n (u :: Bag Bool             )+    "Bag ()"           -> put t n (u :: Bag ()               )+    "Bag Nat"          -> put t n (u :: Bag Nat              )+    "Bag Nat2"         -> put t n (u :: Bag Nat2             )+    "Bag Nat3"         -> put t n (u :: Bag Nat3             )+    "NoDup Bool"       -> put t n (u :: NoDup Bool           )+    "NoDup ()"         -> put t n (u :: NoDup ()             )+    "NoDup Nat"        -> put t n (u :: NoDup Nat            )+    "NoDup Nat2"       -> put t n (u :: NoDup Nat2           )+    "NoDup Nat3"       -> put t n (u :: NoDup Nat3           )+    -- unhandled+    _                  -> putStrLn $ "unknown/unhandled type `" ++ t ++ "'"

+ eg/higher-order.hs view

@@ -0,0 +1,20 @@+import Test.LeanCheck+import Test.LeanCheck.Function++type A = Int++prop_foldlFoldr :: (A -> A -> A) -> A -> [A] -> Bool+prop_foldlFoldr f z xs  =  foldr f z xs == foldl f z xs++prop_foldl1Foldr1Reverse :: (A -> A -> A) -> [A] -> Bool+prop_foldl1Foldr1Reverse f xs  =+  not (null xs) ==> foldl1 f xs ==  foldr1 f (reverse xs)++prop_mapFilter :: (A -> A) -> (A -> Bool) -> [A] -> Bool+prop_mapFilter f p xs  =  filter p (map f xs) == map f (filter p xs)++main :: IO ()+main = do+  check prop_foldlFoldr+  check prop_foldl1Foldr1Reverse+  check prop_mapFilter

+ eg/overflow.hs view

@@ -0,0 +1,52 @@+-- Example taken from Lee Pike's paper on SmartCheck:+-- https://github.com/leepike/SmartCheck/blob/master/paper/paper.pdf+--+-- An enumerative testing library, using a standard enumeration for integers,+-- won't be able to find a counter-example.+--+-- However, if we tweak the enumeration to include extremely large integers+-- (32767, 32766, 32765...) intercalated with extremely small integers a+-- counter-example is found quickly.+--+-- See the 'X' type from "Test.LeanCheck.Utils.Types" for more details.+--+-- The technque shown here could be applied in other enumerative property-based+-- testing tools.+import Test.LeanCheck+import Test.LeanCheck.Utils+import Data.Int++type I  =  [Int16]+data T  =  T I I I I I+  deriving Show++toList :: T -> [[Int16]]+toList (T i j k l m) = [i,j,k,l,m]++pre :: T -> Bool+pre t  =  all ((< 256) . sum) (toList t)++post :: T -> Bool+post t  =  (sum . concat) (toList t) < 5 * 256++prop :: T -> Bool+prop t  =  pre t ==> post t++instance Listable Int16 where+  list = map unX list++instance Listable T where+  tiers = cons5 T++{-+-- In case we start providing a default Listable instance for Int16 with a+-- regular enuemration.  We can use the following Listable T instance.+instance Listable T where+  tiers = cons5 makeT+    where+    makeT (Xs i) (Xs j) (Xs k) (Xs l) (Xs m) = T i j k l m+-}++main :: IO ()+main = do+  checkFor 10000 $ prop

+ eg/test-bool.hs view

@@ -0,0 +1,19 @@+-- test-bool.hs -- example program, testing Bool fns using LeanCheck+--+-- Copyright (c) 2017 Rudy Matela.+-- Distributed under the 3-Clause BSD licence (see the file LICENSE).+import Test.LeanCheck+import Test.LeanCheck.Function+import Test.LeanCheck.Utils++main :: IO ()+main = do+  putStrLn "not . not === id";  check $ identity (not . not)+  putStrLn "(&&) commutes";     check $ commutative (&&)+  putStrLn "(||) commutes";     check $ commutative (||)++  putStrLn "\nAll boolean operators are commutative (wrong)."+  check $ \(&|) -> commutative ((&|) :: Bool -> Bool -> Bool)++  putStrLn "\nAll boolean operators are associative (wrong)."+  check $ \(&|) -> associative ((&|) :: Bool -> Bool -> Bool)

+ eg/test-list.hs view

@@ -0,0 +1,13 @@+-- test-list.hs -- example program, testing Data.List using LeanCheck+--+-- Copyright (c) 2017 Rudy Matela.+-- Distributed under the 3-Clause BSD licence (see the file LICENSE).+import Test.LeanCheck+import Data.List++main :: IO ()+main = do+  -- three wrong properties about Data.List:+  check $ \xs ys -> xs `union` ys == ys `union` (xs :: [Int])+  check $ \xs -> [head xs] == take 1 (xs :: [Int])+  check $ \xs -> head (sort xs :: [Int]) == minimum xs

+ eg/test-sort.hs view

@@ -0,0 +1,30 @@+-- test-sort.hs -- example program, testing sort using LeanCheck+--+-- Copyright (c) 2017 Rudy Matela.+-- Distributed under the 3-Clause BSD licence (see the file LICENSE).+import Test.LeanCheck++-- a faulty sort --+sort :: Ord a => [a] -> [a]+sort []      =  []+sort (x:xs)  =  sort (filter (< x) xs)+             ++ [x]+             ++ sort (filter (> x) xs)++-- some properties about it --+prop_sortOrdered :: Ord a => [a] -> Bool+prop_sortOrdered xs = ordered (sort xs)+  where+  ordered (x:y:xs)  =  x <= y && ordered (y:xs)+  ordered _         =  True++prop_sortCount :: Ord a => a -> [a] -> Bool+prop_sortCount x xs = count x (sort xs) == count x xs+  where+  count x = length . filter (== x)++main :: IO ()+main = do+  check $ (prop_sortOrdered :: [Int] -> Bool)+  check $ (prop_sortCount :: Int -> [Int] -> Bool)+  check $ \xs -> sort (sort xs :: [Int]) == sort xs

leancheck.cabal view

@@ -11,7 +11,7 @@ -- this cabal file too complicated.  -- Rudy  name:                leancheck-version:             0.6.7+version:             0.7.0 synopsis:            Cholesterol-free property-based testing description:   LeanCheck is a simple enumerative property-based testing library.@@ -40,7 +40,26 @@                , TODO.md                , doc/data-invariant.md                , doc/tutorial.md-tested-with: GHC==8.0, GHC==7.10, GHC==7.8, GHC==7.6, GHC==7.4+extra-source-files: .gitignore+                  , eg/test-bool.hs+                  , eg/test-list.hs+                  , eg/test-sort.hs+                  , eg/overflow.hs+                  , eg/higher-order.hs+                  , bench/tiers.hs+                  , .travis.yml+                  , stack.yaml+                  , tests/test-sdist+                  , Makefile+                  , mk/haskell.mk+                  , mk/depend.mk+                  , mk/ghcdeps+                  , mk/haddock-i+                  , mk/All.hs+                  , mk/Toplibs.hs+                  , tests/diff/*.out+                  , tests/diff/eg/*.out+tested-with: GHC==8.2, GHC==8.0, GHC==7.10, GHC==7.8, GHC==7.6, GHC==7.4   source-repository head@@ -50,7 +69,7 @@ source-repository this   type:            git   location:        https://github.com/rudymatela/leancheck-  tag:             v0.6.7+  tag:             v0.7.0  library   exposed-modules: Test.LeanCheck@@ -64,13 +83,18 @@                  , Test.LeanCheck.Utils.Types                  , Test.LeanCheck.Utils.TypeBinding                  , Test.LeanCheck.Utils.Operators+                 , Test.LeanCheck.Stats                  , Test.LeanCheck.Function-                 , Test.LeanCheck.Function.ListsOfPairs-                 , Test.LeanCheck.Function.FunListable-                 , Test.LeanCheck.Function.CoListable                  , Test.LeanCheck.Function.Eq-                 , Test.LeanCheck.Function.Periodic                  , Test.LeanCheck.Function.Show+                 , Test.LeanCheck.Function.Listable+                 , Test.LeanCheck.Function.Listable.ListsOfPairs+                 , Test.LeanCheck.Function.Listable.FunListable+                 , Test.LeanCheck.Function.Listable.CoListable+                 , Test.LeanCheck.Function.Listable.Periodic+                 , Test.LeanCheck.Function.Listable.Mixed+                 , Test.LeanCheck.Function.ListsOfPairs+                 , Test.LeanCheck.Function.CoListable                  , Test.LeanCheck.Function.ShowFunction   hs-source-dirs:      src   build-depends:       base >= 4 && < 5, template-haskell@@ -119,6 +143,38 @@ test-suite error   type:                exitcode-stdio-1.0   main-is:             test-error.hs+  other-modules:       Test+  hs-source-dirs:      tests+  build-depends:       base >= 4 && < 5, leancheck+  default-language:    Haskell2010++test-suite io+  type:                exitcode-stdio-1.0+  main-is:             test-io.hs+  other-modules:       Test+  hs-source-dirs:      tests+  build-depends:       base >= 4 && < 5, leancheck+  default-language:    Haskell2010++test-suite fun+  type:                exitcode-stdio-1.0+  main-is:             test-fun.hs+  other-modules:       Test+  hs-source-dirs:      tests+  build-depends:       base >= 4 && < 5, leancheck+  default-language:    Haskell2010++test-suite funshow+  type:                exitcode-stdio-1.0+  main-is:             test-funshow.hs+  other-modules:       Test+  hs-source-dirs:      tests+  build-depends:       base >= 4 && < 5, leancheck+  default-language:    Haskell2010++test-suite stats+  type:                exitcode-stdio-1.0+  main-is:             test-stats.hs   other-modules:       Test   hs-source-dirs:      tests   build-depends:       base >= 4 && < 5, leancheck

+ mk/All.hs view

@@ -0,0 +1,14 @@+module All+  ( module Test.LeanCheck+  , module Test.LeanCheck.Core+  , module Test.LeanCheck.Basic+  , module Test.LeanCheck.Utils+  , module Test.LeanCheck.Tiers+  )+where++import Test.LeanCheck+import Test.LeanCheck.Core+import Test.LeanCheck.Basic+import Test.LeanCheck.Utils+import Test.LeanCheck.Tiers

+ mk/Toplibs.hs view

@@ -0,0 +1,7 @@+-- Using ghc --make in this module triggers compilation of every library.+module Toplibs () where++import Test.LeanCheck ()+import Test.LeanCheck.Utils ()+import Test.LeanCheck.Error ()+import Test.LeanCheck.Function ()

+ mk/depend.mk view

@@ -0,0 +1,590 @@+bench/tiers: \+  bench/tiers.hs \+  mk/toplibs+bench/tiers-colistable: \+  bench/tiers-colistable.hs \+  mk/toplibs+bench/tiers-colistable.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Function/Listable/CoListable.hs \+  src/Test/LeanCheck/Function/Eq.hs \+  src/Test/LeanCheck/Function/CoListable.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  bench/tiers-colistable.hs+bench/tiers-funlistable: \+  bench/tiers-funlistable.hs \+  mk/toplibs+bench/tiers-funlistable.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Function/Listable/FunListable.hs \+  src/Test/LeanCheck/Function/Eq.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  bench/tiers-funlistable.hs+bench/tiers-listsofpairs: \+  bench/tiers-listsofpairs.hs \+  mk/toplibs+bench/tiers-listsofpairs.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Eq.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  bench/tiers-listsofpairs.hs+bench/tiers-mixed: \+  bench/tiers-mixed.hs \+  mk/toplibs+bench/tiers-mixed.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Listable/Mixed.hs \+  src/Test/LeanCheck/Function/Eq.hs \+  src/Test/LeanCheck/Function/CoListable.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  bench/tiers-mixed.hs+bench/tiers.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Function.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Listable.hs \+  src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Eq.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  bench/tiers.hs+eg/higher-order: \+  eg/higher-order.hs \+  mk/toplibs+eg/higher-order.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Function.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Listable.hs \+  src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  eg/higher-order.hs+eg/overflow: \+  eg/overflow.hs \+  mk/toplibs+eg/overflow.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  eg/overflow.hs+eg/test-bool: \+  eg/test-bool.hs \+  mk/toplibs+eg/test-bool.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Function.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Listable.hs \+  src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  eg/test-bool.hs+eg/test-list: \+  eg/test-list.hs \+  mk/toplibs+eg/test-list.o: \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  eg/test-list.hs+eg/test-sort: \+  eg/test-sort.hs \+  mk/toplibs+eg/test-sort.o: \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  eg/test-sort.hs+mk/All.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  mk/All.hs+mk/Toplibs.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Function.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Listable.hs \+  src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs \+  mk/Toplibs.hs+src/Test/LeanCheck/Basic.o: \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Core.o: \+  src/Test/LeanCheck/Core.hs+src/Test/LeanCheck/Derive.o: \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Error.o: \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function/CoListable.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/CoListable.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function/Eq.o: \+  src/Test/LeanCheck/Function/Eq.hs \+  src/Test/LeanCheck/Core.hs+src/Test/LeanCheck/Function/Listable/CoListable.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Listable/CoListable.hs \+  src/Test/LeanCheck/Function/CoListable.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function/Listable/FunListable.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Listable/FunListable.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function/Listable/ListsOfPairs.o: \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function/Listable/Mixed.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Listable/Mixed.hs \+  src/Test/LeanCheck/Function/CoListable.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function/Listable.o: \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Listable.hs \+  src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function/Listable/Periodic.o: \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Listable/Periodic.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function/ListsOfPairs.o: \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Function.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Function/Listable.hs \+  src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function/ShowFunction.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Function/Show.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/IO.o: \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Core.hs+src/Test/LeanCheck.o: \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Stats.o: \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck/Core.hs+src/Test/LeanCheck/Tiers.o: \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Utils/Operators.o: \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Utils.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Utils/TypeBinding.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+src/Test/LeanCheck/Utils/Types.o: \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-derive.o: \+  tests/Test.hs \+  tests/test-derive.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-derive: \+  tests/Test.hs \+  tests/test-derive.hs \+  mk/toplibs+tests/test-error.o: \+  tests/Test.hs \+  tests/test-error.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-error: \+  tests/Test.hs \+  tests/test-error.hs \+  mk/toplibs+tests/test-fun.o: \+  tests/Test.hs \+  tests/test-fun.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/ListsOfPairs.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-funshow.o: \+  tests/Test.hs \+  tests/test-funshow.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Function/Show.hs \+  src/Test/LeanCheck/Function/ShowFunction.hs \+  src/Test/LeanCheck/Error.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-funshow: \+  tests/Test.hs \+  tests/test-funshow.hs \+  mk/toplibs+tests/test-fun: \+  tests/Test.hs \+  tests/test-fun.hs \+  mk/toplibs+tests/test-io.o: \+  tests/Test.hs \+  tests/test-io.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-io: \+  tests/Test.hs \+  tests/test-io.hs \+  mk/toplibs+tests/test-operators.o: \+  tests/Test.hs \+  tests/test-operators.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-operators: \+  tests/Test.hs \+  tests/test-operators.hs \+  mk/toplibs+tests/Test.o: \+  tests/Test.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test.o: \+  tests/Test.hs \+  tests/test.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-stats.o: \+  tests/test-stats.hs \+  tests/Test.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-stats: \+  tests/test-stats.hs \+  tests/Test.hs \+  mk/toplibs+tests/test: \+  tests/Test.hs \+  tests/test.hs \+  mk/toplibs+tests/test-tiers.o: \+  tests/test-tiers.hs \+  tests/Test.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Utils/TypeBinding.hs \+  src/Test/LeanCheck/Utils.hs \+  src/Test/LeanCheck/Utils/Operators.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck/Stats.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-tiers: \+  tests/test-tiers.hs \+  tests/Test.hs \+  mk/toplibs+tests/test-types.o: \+  tests/test-types.hs \+  tests/Test.hs \+  src/Test/LeanCheck/Utils/Types.hs \+  src/Test/LeanCheck/Tiers.hs \+  src/Test/LeanCheck.hs \+  src/Test/LeanCheck/IO.hs \+  src/Test/LeanCheck/Derive.hs \+  src/Test/LeanCheck/Core.hs \+  src/Test/LeanCheck/Basic.hs+tests/test-types: \+  tests/test-types.hs \+  tests/Test.hs \+  mk/toplibs

+ mk/ghcdeps view

@@ -0,0 +1,49 @@+#!/bin/bash+#+# ghcdeps: generate Haskell make dependencies for compiling with GHC.+#+# Copyright (c) 2015-2017 Rudy Matela.+# Distributed under the 3-Clause BSD licence.+#+# From a list of files provided on standard input,+# generate flat make dependencies.+#+# Transitive relations are repeated.+#+# Usage:+#   $ ghcdeps -isomedir:someother <<LIST+#   program.hs+#   Library.hs+#   Path/To/Library.hs+#   LIST+#   program: ...+#   Library.o: ...+#   Path/To/Library.o: ...+#+# Or:+#   $ find -name \*.hs -o -name \*.lhs | ghcdeps [GHCFLAGS]+#   ...+#+# Note that when using find, you have to remember to exclude unecessary files,+# e.g.:  dist, Setup.hs+#+# Yes, this is hacky.  But hey, it works.+while read fn+do+	ghc "$@" -dep-suffix=. -dep-makefile=tmp.mk -M "$fn" ||+	exit 1+	deps="`cat tmp.mk |+	       grep "hs$" |+	       sort |+	       sed -e "s/.*: //" |+	       tac |+	       tr '\n' ' ' |+	       sed -e "s/ $//"`"+	obj=`echo $fn | sed -e 's,^\./,,;s/\.hs$/.o/'`+	bin=`echo $fn | sed -e 's,^\./,,;s/\.hs$//'`+	echo "$obj: $deps"+	grep -q "main" "$fn" && echo "$bin: `echo $deps | sed -e 's|[^ ]*src[^ ]*||g'` mk/toplibs"+	rm -f tmp.mk+done |+sort |+sed -e 's,  *, \\\n  ,g'

+ mk/haddock-i view

@@ -0,0 +1,24 @@+#!/bin/bash+#+# haddock-i: list haddock's -i parameters.+#+# Copyright (c) 2015-2017 Rudy Matela.+# Distributed under the 3-Clause BSD licence.+#+# $ haddock-i <package1> <package2> ... <packageN>+#+# will print -i parameters necessary for haddock to link to Haddock+# documentation installed on your system, so you can:+#+# $ haddock-i base template-haskell | xargs haddock <files>+errxit() {+	echo "$@" > /dev/stderr+	exit 1+}++for pkg in "$@"; do+	ghc-pkg field $pkg haddock-html,haddock-interfaces ||+	errxit "error: haddock-i: cannot find package $pkg (ghc-pkg)"+done |+sed "s/.*: //" |+sed "N;s/\n/,/;s/^/-i/"

+ mk/haskell.mk view

@@ -0,0 +1,65 @@+# Implicit rules for compiling Haskell code.+#+# Copyright (c) 2015-2017 Rudy Matela.+# Distributed under the 3-Clause BSD licence.+#+# You can optionally configure the "Configuration variables" below in your main+# makefile, e.g.:+#+#   GHCIMPORTDIRS = path/to/dir:path/to/another/dir+#   GHCFLAGS = -O2 -dynamic+#   GHC = ghc-7.6+#   include haskell.mk++++# Configuration variables++# GHC Parameters+GHCIMPORTDIRS ?=+GHCFLAGS ?=+GHC ?= ghc++# Makefile where to keep the dependencies+DEPMK ?= mk/depend.mk++# By default, excludes dist and Setup.hs, so that a Makefile can coexist nicely+# in a cabalized project.  Also excludes .stack-work.+HSS ?= $(shell find \( -path "./dist" -o -path "./Setup.hs" -o -path "./.stack-work" \) -prune \+                 -o -name "*.*hs" -print)+# You can override HSS in your main Makefile+# It should include all Haskell sources to be compiled by different targets+# (even those that are not a dependency to all)+# It will be used to generate dependencies and for cleaning objects++++# Implicit rules+GHCCMD = $(GHC) -i$(GHCIMPORTDIRS) $(GHCFLAGS)++%.hi %.o: %.hs+	$(GHCCMD) $< && touch $@++%: %.hs+	$(GHCCMD) $< && touch $@++.PHONY: %.ghci+%.ghci: %.hs+	$(GHCCMD) -O0 --interactive $<+++# Cleaning rule (add as a clean dependency)+.PHONY: clean-hi-o+clean-hi-o:+	find $(HSS) | sed -e 's/hs$$/o/'      | xargs rm -f+	find $(HSS) | sed -e 's/hs$$/hi/'     | xargs rm -f+	find $(HSS) | sed -e 's/hs$$/dyn_o/'  | xargs rm -f+	find $(HSS) | sed -e 's/hs$$/dyn_hi/' | xargs rm -f+++# Update dependency file+.PHONY: depend+depend:+	find $(HSS) | ./mk/ghcdeps -i$(GHCIMPORTDIRS) $(GHCFLAGS) > $(DEPMK)++include $(DEPMK)

src/Test/LeanCheck/Derive.hs view

@@ -19,6 +19,8 @@   ( deriveListable   , deriveListableIfNeeded   , deriveListableCascading+  , deriveTiers+  , deriveList   ) where @@ -86,19 +88,26 @@ #endif #if __GLASGOW_HASKELL__ >= 708   cxt |=>| [d| instance Listable $(return nt)-                 where tiers = $(conse =<< typeConstructors t) |]+                 where tiers = $(deriveTiers t) |] #else-  tiersE <- conse =<< typeConstructors t+  tiersE <- deriveTiers t   return [ InstanceD              cxt              (AppT (ConT ''Listable) nt)              [ValD (VarP 'tiers) (NormalB tiersE) []]          ] #endif-  where cone n as = do-          (Just consN) <- lookupValueName $ "cons" ++ show (length as)-          [| $(varE consN) $(conE n) |]-        conse = foldr1 (\e1 e2 -> [| $e1 \/ $e2 |]) . map (uncurry cone)++deriveTiers :: Name -> ExpQ+deriveTiers t = conse =<< typeConstructors t+  where+  cone n as = do+    (Just consN) <- lookupValueName $ "cons" ++ show (length as)+    [| $(varE consN) $(conE n) |]+  conse = foldr1 (\e1 e2 -> [| $e1 \/ $e2 |]) . map (uncurry cone)++deriveList :: Name -> ExpQ+deriveList t = [| concat $(deriveTiers t) |]  -- Not only really derive Listable instances, -- but cascade through argument types.

src/Test/LeanCheck/Function.hs view

@@ -11,26 +11,8 @@ -- These can be useful for testing higher-order properties --- properties that -- take functions as arguments. ----- LeanCheck provides several alternative definitions of 'Listable' functions:------ * "Test.LeanCheck.Function.ListsOfPairs":---   considers functions as a finite list of exceptional input-output cases to---   a default value (list of pairs of arguments and results).---   This is the LeanCheck default, and is the one exported by this module.------ * "Test.LeanCheck.Function.CoListable":---   declares a 'CoListable' typeclass similar to SmallCheck's @CoSerial@.---   Currently a stub.------ * "Test.LeanCheck.Function.Periodic":---   similar to ListsOfPairs, but instead of having a default value, functions---   are periodic.------ Take care: all the above 'Listable' instances are __experimental__.  Only--- one of the above can be imported at a time.--- -- Warning: this is only intended to be used in testing modules.  Avoid -- importing this on modules that are used as libraries. module Test.LeanCheck.Function () where-import Test.LeanCheck.Function.ListsOfPairs ()+import Test.LeanCheck.Function.Listable () import Test.LeanCheck.Function.Show ()

src/Test/LeanCheck/Function/CoListable.hs view

@@ -1,5 +1,5 @@ -- |--- Module      : Test.LeanCheck.CoListable+-- Module      : Test.LeanCheck.Function.CoListable -- Copyright   : (c) 2015-2017 Rudy Matela -- License     : 3-Clause BSD  (see the file LICENSE) -- Maintainer  : Rudy Matela <rudy@matela.com.br>@@ -7,12 +7,14 @@ -- This module is part of LeanCheck, -- a simple enumerative property-based testing library. ----- This module exports a 'Listable' instance for function enumeration by means--- of a 'CoListable' typeclass.  This is very similar to the coseries--- enumeration of SmallCheck.+-- This module exports functions to define a 'Listable' instance for function+-- enumeration by means of a 'CoListable' typeclass.  This is very similar to+-- the coseries enumeration of SmallCheck. -- -- This module /does not currently work/, it it just a sketch and a stub. module Test.LeanCheck.Function.CoListable+  ( CoListable (..)+  ) where  @@ -20,10 +22,6 @@ import Test.LeanCheck.Tiers import Test.LeanCheck.Utils (Nat(..), Nat2(..), Nat3(..)) import Data.Maybe (fromMaybe)---instance (CoListable a, Listable b) => Listable (a -> b) where-  tiers = cotiers tiers   (\+:/) :: [[a]] -> [[a]] -> [[a]]

− src/Test/LeanCheck/Function/FunListable.hs

@@ -1,133 +0,0 @@--- |--- Module      : Test.LeanCheck.FunListable--- Copyright   : (c) 2015-2017 Rudy Matela--- License     : 3-Clause BSD  (see the file LICENSE)--- Maintainer  : Rudy Matela <rudy@matela.com.br>------ This module is part of LeanCheck,--- a simple enumerative property-based testing library.------ This module exports a 'Listable' instance for function enumeration by means--- of a 'FunListable' typeclass (similar to 'FunListable').------ This module /does not currently work/, it it just a sketch and a stub.-module Test.LeanCheck.Function.FunListable-where---import Test.LeanCheck-import Test.LeanCheck.Tiers-import Test.LeanCheck.Utils (Nat(..), Nat2(..), Nat3(..))-import Data.Maybe (fromMaybe)---sndArgTypeOf :: b -> (a -> b -> c) -> b-x `sndArgTypeOf` _ = x---instance (FunListable a, Listable b) => Listable (a -> b) where-  tiers = concatMapT mkfss funtiers-    where-    mkfss (n, mkf) = mapT mkf (products (replicate n tiers)-                    `suchThat` validResults (undefined `sndArgTypeOf` mkf))---(\+:/) :: [[a]] -> [[a]] -> [[a]]-xss \+:/ yss = xss \/ ([]:yss)-infixr 9 \+:/---class FunListable a where-  validResults   :: a -> [b] -> Bool-  validResults   x  =  not . invalidResults x-  invalidResults :: a -> [b] -> Bool-  invalidResults x  =  not .   validResults x-  funtiers :: [[ (Int, [b] -> (a -> b)) ]]---- maybe the other function FunListable needs is a okResults that checks if--- results follow required pattern for each type:---   * for lists, there shouldnt be repeated element suffix---        a,a,a,a,a,b is ok---        a,b,c,d,e,e is not ok.---   * for integers, there shouldnt be adjacent repeated elements---        a,b,a,b,a,b,a,b is ok---        a,b,c,d,e,f,f,g is not ok---        of course, this for the enumeration where I have the points.---   * for pairs, apply the invariants accordingly in the matrix (is that---     possible?)---        I think it is.  Apply one invariant to columns, the other to lines.--instance FunListable () where-  validResults _ _ = True-  funtiers = [[ (1, \[r]  () -> r) ]]---instance FunListable Bool where-  validResults _ _ = True-  funtiers = [[ (2, \[r1,r2]  b -> if b then r1 else r2) ]]---- have funtiers = [[ (1, \[r1]  b -> r1) ]---                  ,[ (1, \[r1]  b -> if b then r1 else not r1 ]---                  ]---instance FunListable a => FunListable (Maybe a) where-  validResults _ _   =  True-  funtiers = mapT (\(n, mkf) -> (n+1, \(r:rs)  m -> case m of-                                                       Nothing -> r-                                                       Just x  -> mkf rs x)) funtiers---instance (FunListable a, FunListable b) => FunListable (Either a b) where-  validResults _ _  =  True-  funtiers = productWith-                (\(nf, mf) (ng, mg) -> (nf + ng, \rs  e -> case e of-                                                             Left  x -> mf (take nf rs) x-                                                             Right y -> mg (drop nf rs) y))-                funtiers-                funtiers----- NOTE: big problem: adding r1 == r2 below instroduces an Eq restriction on--- the result type.  Which does not exist for (a->b).  Maybe create a new--- typeclass: FunResult, then rename FunListable to FunArg.  This way we can--- have the equality check (or any other special checks) for types that have--- equality and ignore it for types that don't.-instance (FunListable a) => FunListable [a] where-  validResults _ [r1,r2]  {- -- | r1 == r2 -} =  False  -- The results cannot end with repetitions-  validResults x (r:rs)   =  validResults x rs-  validResults _ _        =  True-  funtiers = [[ (1, \[r]  xs -> r) ]]-         \+:/ mapT (\(n, f) -> (1 + n, \(r:rs)  xs -> case xs of-                                                        []     -> r-                                                        (x:xs) -> f rs (x,xs))) funtiers---instance (FunListable a, FunListable b) => FunListable (a,b) where-  validResults _ _  =  True  -- TODO: check lines and columns-  funtiers = productWith (\(n, f)  (m, g)-                            -> (n*m, \rs  (x,y) -> toMatrix m rs-                                                !! f [0..(n-1)] x-                                                !! g [0..(m-1)] y))-                funtiers-                funtiers---toMatrix :: Int -> [a] -> [[a]]-toMatrix n [] = []-toMatrix n xs = take n xs-              : toMatrix n (drop n xs)---instance FunListable Int where-  funtiers = [[]] -- TODO: implement funtiers :: [[...Int...]]-  -- mapT (... findInterval something ...) tiers--instance FunListable Nat where-  funtiers = [[]] -- TODO: implement funtiers :: [[...Nat...]]--instance FunListable Nat2 where-  funtiers = [[]] -- TODO: implement funtiers :: [[...Nat2...]]--instance FunListable Nat3 where-  funtiers = [[]] -- TODO: implement funtiers :: [[...Nat3...]]

+ src/Test/LeanCheck/Function/Listable.hs view

@@ -0,0 +1,34 @@+-- |+-- Module      : Test.LeanCheck.Function.Listable+-- Copyright   : (c) 2015-2017 Rudy Matela+-- License     : 3-Clause BSD  (see the file LICENSE)+-- Maintainer  : Rudy Matela <rudy@matela.com.br>+--+-- This module is part of LeanCheck,+-- a simple enumerative property-based testing library.+--+-- This module exports a 'Listable' instance for functions.+--+-- LeanCheck provides several alternative definitions of 'Listable' functions:+--+-- * "Test.LeanCheck.Function.Listable.ListsOfPairs":+--   considers functions as a finite list of exceptional input-output cases to+--   a default value (list of pairs of arguments and results).+--   This is the LeanCheck default, and is the one exported by this module.+--+-- * "Test.LeanCheck.Function.Listable.CoListable":+--   declares a 'CoListable' typeclass similar to SmallCheck's @CoSerial@.+--   Currently a stub.+--+-- * "Test.LeanCheck.Function.Listable.Periodic":+--   similar to ListsOfPairs, but instead of having a default value, functions+--   are periodic.+--+-- Take care: all the above 'Listable' instances are __experimental__.  Only+-- one of the above can be imported at a time.+--+-- Warning: this is only intended to be used in testing modules.  Avoid+-- importing this on modules that are used as libraries.+module Test.LeanCheck.Function.Listable () where++import Test.LeanCheck.Function.Listable.ListsOfPairs

+ src/Test/LeanCheck/Function/Listable/CoListable.hs view

@@ -0,0 +1,21 @@+-- |+-- Module      : Test.LeanCheck.Function.Listable.CoListable+-- Copyright   : (c) 2015-2017 Rudy Matela+-- License     : 3-Clause BSD  (see the file LICENSE)+-- Maintainer  : Rudy Matela <rudy@matela.com.br>+--+-- This module is part of LeanCheck,+-- a simple enumerative property-based testing library.+--+-- This module exports a 'Listable' instance for function enumeration by means+-- of a 'CoListable' typeclass.  This is very similar to the coseries+-- enumeration of SmallCheck.+--+-- This module /does not currently work/, it it just a sketch and a stub.+module Test.LeanCheck.Function.Listable.CoListable () where++import Test.LeanCheck.Core+import Test.LeanCheck.Function.CoListable++instance (CoListable a, Listable b) => Listable (a -> b) where+  tiers = cotiers tiers

+ src/Test/LeanCheck/Function/Listable/FunListable.hs view

@@ -0,0 +1,133 @@+-- |+-- Module      : Test.LeanCheck.FunListable+-- Copyright   : (c) 2015-2017 Rudy Matela+-- License     : 3-Clause BSD  (see the file LICENSE)+-- Maintainer  : Rudy Matela <rudy@matela.com.br>+--+-- This module is part of LeanCheck,+-- a simple enumerative property-based testing library.+--+-- This module exports a 'Listable' instance for function enumeration by means+-- of a 'FunListable' typeclass (similar to 'CoListable').+--+-- This module /does not currently work/, it it just a sketch and a stub.+module Test.LeanCheck.Function.Listable.FunListable+where+++import Test.LeanCheck+import Test.LeanCheck.Tiers+import Test.LeanCheck.Utils (Nat(..), Nat2(..), Nat3(..))+import Data.Maybe (fromMaybe)+++sndArgTypeOf :: b -> (a -> b -> c) -> b+x `sndArgTypeOf` _ = x+++instance (FunListable a, Listable b) => Listable (a -> b) where+  tiers = concatMapT mkfss funtiers+    where+    mkfss (n, mkf) = mapT mkf (products (replicate n tiers)+                    `suchThat` validResults (undefined `sndArgTypeOf` mkf))+++(\+:/) :: [[a]] -> [[a]] -> [[a]]+xss \+:/ yss = xss \/ ([]:yss)+infixr 9 \+:/+++class FunListable a where+  validResults   :: a -> [b] -> Bool+  validResults   x  =  not . invalidResults x+  invalidResults :: a -> [b] -> Bool+  invalidResults x  =  not .   validResults x+  funtiers :: [[ (Int, [b] -> (a -> b)) ]]++-- maybe the other function FunListable needs is a okResults that checks if+-- results follow required pattern for each type:+--   * for lists, there shouldnt be repeated element suffix+--        a,a,a,a,a,b is ok+--        a,b,c,d,e,e is not ok.+--   * for integers, there shouldnt be adjacent repeated elements+--        a,b,a,b,a,b,a,b is ok+--        a,b,c,d,e,f,f,g is not ok+--        of course, this for the enumeration where I have the points.+--   * for pairs, apply the invariants accordingly in the matrix (is that+--     possible?)+--        I think it is.  Apply one invariant to columns, the other to lines.++instance FunListable () where+  validResults _ _ = True+  funtiers = [[ (1, \[r]  () -> r) ]]+++instance FunListable Bool where+  validResults _ _ = True+  funtiers = [[ (2, \[r1,r2]  b -> if b then r1 else r2) ]]++-- have funtiers = [[ (1, \[r1]  b -> r1) ]+--                  ,[ (1, \[r1]  b -> if b then r1 else not r1 ]+--                  ]+++instance FunListable a => FunListable (Maybe a) where+  validResults _ _   =  True+  funtiers = mapT (\(n, mkf) -> (n+1, \(r:rs)  m -> case m of+                                                       Nothing -> r+                                                       Just x  -> mkf rs x)) funtiers+++instance (FunListable a, FunListable b) => FunListable (Either a b) where+  validResults _ _  =  True+  funtiers = productWith+                (\(nf, mf) (ng, mg) -> (nf + ng, \rs  e -> case e of+                                                             Left  x -> mf (take nf rs) x+                                                             Right y -> mg (drop nf rs) y))+                funtiers+                funtiers+++-- NOTE: big problem: adding r1 == r2 below instroduces an Eq restriction on+-- the result type.  Which does not exist for (a->b).  Maybe create a new+-- typeclass: FunResult, then rename FunListable to FunArg.  This way we can+-- have the equality check (or any other special checks) for types that have+-- equality and ignore it for types that don't.+instance (FunListable a) => FunListable [a] where+  validResults _ [r1,r2]  {- -- | r1 == r2 -} =  False  -- The results cannot end with repetitions+  validResults x (r:rs)   =  validResults x rs+  validResults _ _        =  True+  funtiers = [[ (1, \[r]  xs -> r) ]]+         \+:/ mapT (\(n, f) -> (1 + n, \(r:rs)  xs -> case xs of+                                                        []     -> r+                                                        (x:xs) -> f rs (x,xs))) funtiers+++instance (FunListable a, FunListable b) => FunListable (a,b) where+  validResults _ _  =  True  -- TODO: check lines and columns+  funtiers = productWith (\(n, f)  (m, g)+                            -> (n*m, \rs  (x,y) -> toMatrix m rs+                                                !! f [0..(n-1)] x+                                                !! g [0..(m-1)] y))+                funtiers+                funtiers+++toMatrix :: Int -> [a] -> [[a]]+toMatrix n [] = []+toMatrix n xs = take n xs+              : toMatrix n (drop n xs)+++instance FunListable Int where+  funtiers = [[]] -- TODO: implement funtiers :: [[...Int...]]+  -- mapT (... findInterval something ...) tiers++instance FunListable Nat where+  funtiers = [[]] -- TODO: implement funtiers :: [[...Nat...]]++instance FunListable Nat2 where+  funtiers = [[]] -- TODO: implement funtiers :: [[...Nat2...]]++instance FunListable Nat3 where+  funtiers = [[]] -- TODO: implement funtiers :: [[...Nat3...]]

+ src/Test/LeanCheck/Function/Listable/ListsOfPairs.hs view

@@ -0,0 +1,21 @@+-- |+-- Module      : Test.LeanCheck.Function.ListsOfPairs+-- Copyright   : (c) 2015-2017 Rudy Matela+-- License     : 3-Clause BSD  (see the file LICENSE)+-- Maintainer  : Rudy Matela <rudy@matela.com.br>+--+-- This module is part of LeanCheck,+-- a simple enumerative property-based testing library.+--+-- This module exports a 'Listable' instance for function enumeration+-- via lists of pairs.+--+-- This module considers functions as a finite list of exceptional input-output+-- cases to a default value (list of pairs of arguments and results).+module Test.LeanCheck.Function.Listable.ListsOfPairs () where++import Test.LeanCheck.Core+import Test.LeanCheck.Function.ListsOfPairs++instance (Eq a, Listable a, Listable b) => Listable (a -> b) where+  tiers = tiers -->> tiers

+ src/Test/LeanCheck/Function/Listable/Mixed.hs view

@@ -0,0 +1,20 @@+-- |+-- Module      : Test.LeanCheck.Function.Mixed+-- Copyright   : (c) 2015-2017 Rudy Matela+-- License     : 3-Clause BSD  (see the file LICENSE)+-- Maintainer  : Rudy Matela <rudy@matela.com.br>+--+-- This module is part of LeanCheck,+-- a simple enumerative property-based testing library.+--+-- This module exports a 'Listable' instance for function enumeration+-- by combining several enumeration strategies.+module Test.LeanCheck.Function.Listable.Mixed () where++import Test.LeanCheck.Core+import Test.LeanCheck.Function.ListsOfPairs+import Test.LeanCheck.Function.CoListable++instance (Eq a, Listable a, CoListable a, Listable b) => Listable (a -> b) where+  tiers = tiers -->> tiers+       \/ cotiers tiers

+ src/Test/LeanCheck/Function/Listable/Periodic.hs view

@@ -0,0 +1,57 @@+-- |+-- Module      : Test.LeanCheck.Function.Periodic+-- Copyright   : (c) 2015-2017 Rudy Matela+-- License     : 3-Clause BSD  (see the file LICENSE)+-- Maintainer  : Rudy Matela <rudy@matela.com.br>+--+-- This module is part of LeanCheck,+-- a simple enumerative property-based testing library.+--+-- This module exports a 'Listable' instance for enumeration of periodic+-- functions.+--+-- This module /barely works/ and is just a sketch.+module Test.LeanCheck.Function.Listable.Periodic+where+++import Test.LeanCheck+import Data.List (inits)+++instance (Eq a, Eq b, Listable a, Listable b) => Listable (a -> b) where+  tiers = mapT pairsToFunction $ functions list tiers++functions :: Eq b => [a] -> [[b]] -> [[[(a,b)]]]+functions xs yss = mapT (zip xs . cycle) $ lsPeriodsOfLimit xs yss++functionsz :: Eq b => [[a]] -> [[b]] -> [[[(a,b)]]]+functionsz xss = functions (concat xss)+++lsPeriodsOf :: Eq a => [[a]] -> [[[a]]]+lsPeriodsOf xss = map (filter isPeriod) (listsOf xss)++lsPeriodsOfLimit :: Eq a => [b] -> [[a]] -> [[[a]]]+lsPeriodsOfLimit ys xss = map (filter isPeriod) (tiersOfLimit ys xss)+++isPeriod :: Eq a => [a] -> Bool+isPeriod [] = False+isPeriod [x] = True+isPeriod xs = not $ any (`isPeriodOf` xs) $ (tail . init . inits) xs++isPeriodOf :: Eq a => [a] -> [a] -> Bool+xs `isPeriodOf` ys = length ys `mod` length xs == 0+                  && and (zipWith (==) (cycle xs) ys)+++tiersOfLimit :: [b] -> [[a]] -> [[[a]]]+tiersOfLimit     [] xss = [[[]]]+tiersOfLimit (_:ys) xss = [[[]]] ++ productWith (:) xss (tiersOfLimit ys xss)+++pairsToFunction :: Eq a => [(a,b)] -> (a -> b)+pairsToFunction ((x,y):ps) x' =  if x' == x+                                   then y+                                   else pairsToFunction ps x'

src/Test/LeanCheck/Function/ListsOfPairs.hs view

@@ -7,14 +7,13 @@ -- This module is part of LeanCheck, -- a simple enumerative property-based testing library. ----- This module exports a 'Listable' instance for function enumeration--- via lists of pairs.+-- This module exports means to enumerate functions via lists of pairs. -- -- This module considers functions as a finite list of exceptional input-output -- cases to a default value (list of pairs of arguments and results). module Test.LeanCheck.Function.ListsOfPairs-  ( functionPairs-  , associations+  ( (-->>)+  , exceptionPairs   ) where @@ -22,16 +21,12 @@ import Test.LeanCheck.Tiers import Data.Maybe (fromMaybe) -instance (Eq a, Listable a, Listable b) => Listable (a -> b) where-  tiers = tiers -->> tiers-- (-->>) :: Eq a => [[a]] -> [[b]] -> [[a->b]] xss -->> yss   | finite xss = mapT ((undefined `mutate`) . zip (concat xss))                       (products $ replicate (length $ concat xss) yss)   | otherwise  = concatMapT-                   (\(r,yss) -> mapT (const r `mutate`) (functionPairs xss yss))+                   (\(r,yss) -> mapT (const r `mutate`) (exceptionPairs xss yss))                    (choices yss)  @@ -41,18 +36,17 @@   mut (x',fx') f x = if x == x' then fx' else f x  --- | Given a list of domain values, and tiers of codomain values,--- return tiers of lists of ordered pairs of domain and codomain values.------ Technically: tiers of left-total functional relations.-associations :: [a] -> [[b]] -> [[ [(a,b)] ]]-associations xs sbs = zip xs `mapT` products (const sbs `map` xs)- -- | Given tiers of input values and tiers of output values, -- return tiers with all possible lists of input-output pairs.--- Those represent functional relations.-functionPairs :: [[a]] -> [[b]] -> [[ [(a,b)] ]]-functionPairs xss yss = concatMapT (`associations` yss) (incompleteSetsOf xss)+-- These represent functional relations.+-- In the implementation of '-->>',+-- they represent exceptions to a constant function,+-- hence the name 'exceptionPairs'.+exceptionPairs :: [[a]] -> [[b]] -> [[ [(a,b)] ]]+exceptionPairs xss yss = concatMapT (`excep` yss) (incompleteSetsOf xss)+  where+  excep :: [a] -> [[b]] -> [[ [(a,b)] ]]+  excep xs sbs = zip xs `mapT` products (const sbs `map` xs) -- incompleteSetsOf is needed, instead of setsOf, because mutating *all* values -- of a constant function makes no sense (we would have already enumerated that -- function anyway).  As of 2c23c1a, it makes no difference whether

− src/Test/LeanCheck/Function/Periodic.hs

@@ -1,57 +0,0 @@--- |--- Module      : Test.LeanCheck.Function.Periodic--- Copyright   : (c) 2015-2017 Rudy Matela--- License     : 3-Clause BSD  (see the file LICENSE)--- Maintainer  : Rudy Matela <rudy@matela.com.br>------ This module is part of LeanCheck,--- a simple enumerative property-based testing library.------ This module exports a 'Listable' instance for enumeration of periodic--- functions.------ This module /barely works/ and is just a sketch.-module Test.LeanCheck.Function.Periodic-where---import Test.LeanCheck-import Data.List (inits)---instance (Eq a, Eq b, Listable a, Listable b) => Listable (a -> b) where-  tiers = mapT pairsToFunction $ functions list tiers--functions :: Eq b => [a] -> [[b]] -> [[[(a,b)]]]-functions xs yss = mapT (zip xs . cycle) $ lsPeriodsOfLimit xs yss--functionsz :: Eq b => [[a]] -> [[b]] -> [[[(a,b)]]]-functionsz xss = functions (concat xss)---lsPeriodsOf :: Eq a => [[a]] -> [[[a]]]-lsPeriodsOf xss = map (filter isPeriod) (listsOf xss)--lsPeriodsOfLimit :: Eq a => [b] -> [[a]] -> [[[a]]]-lsPeriodsOfLimit ys xss = map (filter isPeriod) (tiersOfLimit ys xss)---isPeriod :: Eq a => [a] -> Bool-isPeriod [] = False-isPeriod [x] = True-isPeriod xs = not $ any (`isPeriodOf` xs) $ (tail . init . inits) xs--isPeriodOf :: Eq a => [a] -> [a] -> Bool-xs `isPeriodOf` ys = length ys `mod` length xs == 0-                  && and (zipWith (==) (cycle xs) ys)---tiersOfLimit :: [b] -> [[a]] -> [[[a]]]-tiersOfLimit     [] xss = [[[]]]-tiersOfLimit (_:ys) xss = [[[]]] ++ productWith (:) xss (tiersOfLimit ys xss)---pairsToFunction :: Eq a => [(a,b)] -> (a -> b)-pairsToFunction ((x,y):ps) x' =  if x' == x-                                   then y-                                   else pairsToFunction ps x'

src/Test/LeanCheck/IO.hs view

@@ -90,13 +90,13 @@ showResult m (OK n)             = "+++ OK, passed " ++ show n ++ " tests"                                ++ takeWhile (\_ -> n < m) " (exhausted)" ++ "." showResult m (Falsified i ce)   = "*** Failed! Falsifiable (after "-                               ++ show i ++ " tests):\n" ++ join ce+                               ++ show i ++ " tests):\n" ++ joinArgs ce showResult m (Exception i ce e) = "*** Failed! Exception '" ++ e ++ "' (after "-                               ++ show i ++ " tests):\n" ++ join ce+                               ++ show i ++ " tests):\n" ++ joinArgs ce --- join the counter-example arguments-join :: [String] -> String-join ce | any ('\n' `elem`) ce = unlines $ map chopBreak ce+-- joinArgs the counter-example arguments+joinArgs :: [String] -> String+joinArgs ce | any ('\n' `elem`) ce = unlines $ map chopBreak ce         | otherwise            = unwords ce  -- chops a line break at the end if there is any

+ src/Test/LeanCheck/Stats.hs view

@@ -0,0 +1,126 @@+-- |+-- Module      : Test.LeanCheck.Stats+-- Copyright   : (c) 2017 Rudy Matela+-- License     : 3-Clause BSD  (see the file LICENSE)+-- Maintainer  : Rudy Matela <rudy@matela.com.br>+--+-- This module is part of LeanCheck,+-- a simple enumerative property-based testing library.+--+-- This module exports functions to compute statistics of Listable instances.+module Test.LeanCheck.Stats+  ( classStats+  , classStatsT+  , conditionStats+  , conditionStatsT++  , classify+  , classifyBy+  , classifyOn+  , counts+  , countsBy+  , countsOn+  )+where++import Test.LeanCheck.Core+import Data.Function (on)+import Data.List (intercalate, transpose)++classStats :: (Listable a, Show b) => Int -> (a -> b) -> IO ()+classStats n f = putStrLn+               . table " "+               . map showCount+               $ countsOn (unquote . show . f) xs+  where+  xs = take n list+  len = length xs+  showCount (s,n) = [ s ++ ":"+                    , show n ++ "/" ++ show len+                    , show (100 * n `div` len) ++ "%"+                    ]++-- TODO: implement this+classStatsT :: (Listable a, Show b) => Int -> (a -> b) -> IO ()+classStatsT = error "classStatsT: not implemented yet, use classStats for now"++conditionStats :: Listable a => Int -> [(String,a->Bool)] -> IO ()+conditionStats n = putStrLn . table " " . map show1+  where+  xs = take n list+  len = length xs+  show1 (s,f) = let c = count f xs+                in [ s ++ ":"+                   , show c ++ "/" ++ show len+                   , show (100 * c `div` len) ++ "%" ]+  count f = length . filter f++-- TODO: implement this+conditionStatsT :: Listable a => Int -> [(String,a->Bool)] -> IO ()+conditionStatsT = error "conditionsStatsT: not implemented yet, use classStats for now"++classify :: Eq a => [a] -> [[a]]+classify = classifyBy (==)++classifyBy :: (a -> a -> Bool) -> [a] -> [[a]]+classifyBy (==) []     = []+classifyBy (==) (x:xs) = (x:filter (== x) xs)+                       : classifyBy (==) (filter (/= x) xs)+  where+  x /= y = not (x == y)++classifyOn :: Eq b => (a -> b) -> [a] -> [[a]]+classifyOn f xs = map (map fst)+                . classifyBy ((==) `on` snd)+                $ map (\x -> (x,f x)) xs++counts :: Eq a => [a] -> [(a,Int)]+counts = map headLength . classify++countsBy :: (a -> a -> Bool) -> [a] -> [(a,Int)]+countsBy (==) = map headLength . classifyBy (==)++countsOn :: Eq b => (a -> b) -> [a] -> [(b,Int)]+countsOn f = map (\xs -> (f $ head xs, length xs)) . classifyOn f++headLength :: [a] -> (a,Int)+headLength xs = (head xs, length xs)++unquote :: String -> String+unquote ('"':s) | last s == '"' = init s+unquote s = s++table :: String -> [[String]] -> String+table s []  = ""+table s sss = unlines+            . map (removeTrailing ' ')+            . map (intercalate s)+            . transpose+            . map (normalize ' ')+            . foldr1 (zipWith (++))+            . map (normalize "" . map lines)+            . normalize ""+            $ sss++-- | Fits a list to a certain width by appending a certain value+--+-- > fit ' ' 6 "str" == "str   "+--+-- > fit 0 6 [1,2,3] == [1,2,3,0,0,0]+fit :: a -> Int -> [a] -> [a]+fit x n xs = replicate (n - length xs) x ++ xs++-- | normalize makes all list the same length by adding a value+--+-- > normalize ["asdf","qw","er"] == normalize ["asdf","qw  ","er  "]+normalize :: a -> [[a]] -> [[a]]+normalize x xs = map (x `fit` maxLength xs) xs++-- | Given a list of lists returns the maximum length+maxLength :: [[a]] -> Int+maxLength = maximum . (0:) . map length++removeTrailing :: Eq a => a -> [a] -> [a]+removeTrailing x = reverse+                 . dropWhile (==x)+                 . reverse

src/Test/LeanCheck/Utils.hs view

@@ -19,9 +19,11 @@   ( module Test.LeanCheck.Utils.Types   , module Test.LeanCheck.Utils.Operators   , module Test.LeanCheck.Utils.TypeBinding+  , module Test.LeanCheck.Stats   ) where  import Test.LeanCheck.Utils.Types import Test.LeanCheck.Utils.Operators import Test.LeanCheck.Utils.TypeBinding+import Test.LeanCheck.Stats

+ stack.yaml view

@@ -0,0 +1,15 @@+# stack.yaml docs:+# https://docs.haskellstack.org/en/stable/yaml_configuration/++# resolver: nightly-2015-09-21+# resolver: ghc-7.10.2+resolver: lts-9.0++packages:+- .++extra-deps: []++flags: {}++extra-package-dbs: []

+ tests/diff/eg/higher-order.out view

@@ -0,0 +1,50 @@+*** Failed! Falsifiable (after 75 tests):+\x y -> case (x,y) of+          (0,0) -> 1+          (0,1) -> 1+          (1,0) -> 0+          (0,-1) -> 1+          (1,1) -> 0+          (-1,0) -> 0+          (0,2) -> 1+          (1,-1) -> 0+          ...+0+[0,0]++*** Failed! Falsifiable (after 130 tests):+\x y -> case (x,y) of+          (0,0) -> 1+          (0,1) -> 1+          (1,0) -> 0+          (0,-1) -> 1+          (1,1) -> 0+          (-1,0) -> 0+          (0,2) -> 1+          (1,-1) -> 0+          ...+[0,0,0]++*** Failed! Falsifiable (after 36 tests):+\x -> case x of+        0 -> 0+        1 -> 0+        -1 -> 0+        2 -> 0+        -2 -> 0+        3 -> 0+        -3 -> 0+        4 -> 0+        ...+\x -> case x of+        0 -> True+        1 -> False+        -1 -> False+        2 -> False+        -2 -> False+        3 -> False+        -3 -> False+        4 -> False+        ...+[1]+

+ tests/diff/eg/overflow.out view

@@ -0,0 +1,2 @@+*** Failed! Falsifiable (after 8792 tests):+(T [] [] [] [-1] [-32768])

+ tests/diff/eg/test-bool.out view

@@ -0,0 +1,29 @@+not . not === id++++ OK, passed 2 tests (exhausted).+(&&) commutes++++ OK, passed 4 tests (exhausted).+(||) commutes++++ OK, passed 4 tests (exhausted).++All boolean operators are commutative (wrong).+*** Failed! Falsifiable (after 10 tests):+\x y -> case (x,y) of+          (False,False) -> False+          (False,True) -> False+          (True,False) -> True+          (True,True) -> False+False+True+++All boolean operators are associative (wrong).+*** Failed! Falsifiable (after 22 tests):+\x y -> case (x,y) of+          (False,False) -> False+          (False,True) -> False+          (True,False) -> True+          (True,True) -> False+True+False+True+

+ tests/diff/eg/test-list.out view

@@ -0,0 +1,6 @@+*** Failed! Falsifiable (after 4 tests):+[] [0,0]+*** Failed! Falsifiable (after 1 tests):+[]+*** Failed! Exception 'Prelude.head: empty list' (after 1 tests):+[]

+ tests/diff/eg/test-sort.out view

@@ -0,0 +1,4 @@++++ OK, passed 200 tests.+*** Failed! Falsifiable (after 4 tests):+0 [0,0]++++ OK, passed 200 tests.

+ tests/diff/tiers-BagBool.out view

@@ -0,0 +1,100 @@+tiers :: [Bag Bool]  =+  [ [Bag []]+  , [ Bag [False]+    , Bag [True]+    ]+  , [ Bag [False,False]+    , Bag [False,True]+    , Bag [True,True]+    ]+  , [ Bag [False,False,False]+    , Bag [False,False,True]+    , Bag [False,True,True]+    , Bag [True,True,True]+    ]+  , [ Bag [False,False,False,False]+    , Bag [False,False,False,True]+    , Bag [False,False,True,True]+    , Bag [False,True,True,True]+    , Bag [True,True,True,True]+    ]+  , [ Bag [False,False,False,False,False]+    , Bag [False,False,False,False,True]+    , Bag [False,False,False,True,True]+    , Bag [False,False,True,True,True]+    , Bag [False,True,True,True,True]+    , Bag [True,True,True,True,True]+    ]+  , [ Bag [False,False,False,False,False,False]+    , Bag [False,False,False,False,False,True]+    , Bag [False,False,False,False,True,True]+    , Bag [False,False,False,True,True,True]+    , Bag [False,False,True,True,True,True]+    , Bag [False,True,True,True,True,True]+    , Bag [True,True,True,True,True,True]+    ]+  , [ Bag [False,False,False,False,False,False,False]+    , Bag [False,False,False,False,False,False,True]+    , Bag [False,False,False,False,False,True,True]+    , Bag [False,False,False,False,True,True,True]+    , Bag [False,False,False,True,True,True,True]+    , Bag [False,False,True,True,True,True,True]+    , Bag [False,True,True,True,True,True,True]+    , Bag [True,True,True,True,True,True,True]+    ]+  , [ Bag [False,False,False,False,False,False,False,False]+    , Bag [False,False,False,False,False,False,False,True]+    , Bag [False,False,False,False,False,False,True,True]+    , Bag [False,False,False,False,False,True,True,True]+    , Bag [False,False,False,False,True,True,True,True]+    , Bag [False,False,False,True,True,True,True,True]+    , Bag [False,False,True,True,True,True,True,True]+    , Bag [False,True,True,True,True,True,True,True]+    , Bag [True,True,True,True,True,True,True,True]+    ]+  , [ Bag [False,False,False,False,False,False,False,False,False]+    , Bag [False,False,False,False,False,False,False,False,True]+    , Bag [False,False,False,False,False,False,False,True,True]+    , Bag [False,False,False,False,False,False,True,True,True]+    , Bag [False,False,False,False,False,True,True,True,True]+    , Bag [False,False,False,False,True,True,True,True,True]+    , Bag [False,False,False,True,True,True,True,True,True]+    , Bag [False,False,True,True,True,True,True,True,True]+    , Bag [False,True,True,True,True,True,True,True,True]+    , Bag [True,True,True,True,True,True,True,True,True]+    ]+  , [ Bag [False,False,False,False,False,False,False,False,False,False]+    , Bag [False,False,False,False,False,False,False,False,False,True]+    , Bag [False,False,False,False,False,False,False,False,True,True]+    , Bag [False,False,False,False,False,False,False,True,True,True]+    , Bag [False,False,False,False,False,False,True,True,True,True]+    , Bag [False,False,False,False,False,True,True,True,True,True]+    , Bag [False,False,False,False,True,True,True,True,True,True]+    , Bag [False,False,False,True,True,True,True,True,True,True]+    , Bag [False,False,True,True,True,True,True,True,True,True]+    , Bag [False,True,True,True,True,True,True,True,True,True]+    , Bag [True,True,True,True,True,True,True,True,True,True]+    ]+  , [ Bag [False,False,False,False,False,False,False,False,False,False,False]+    , Bag [False,False,False,False,False,False,False,False,False,False,True]+    , Bag [False,False,False,False,False,False,False,False,False,True,True]+    , Bag [False,False,False,False,False,False,False,False,True,True,True]+    , Bag [False,False,False,False,False,False,False,True,True,True,True]+    , Bag [False,False,False,False,False,False,True,True,True,True,True]+    , Bag [False,False,False,False,False,True,True,True,True,True,True]+    , Bag [False,False,False,False,True,True,True,True,True,True,True]+    , Bag [False,False,False,True,True,True,True,True,True,True,True]+    , Bag [False,False,True,True,True,True,True,True,True,True,True]+    , Bag [False,True,True,True,True,True,True,True,True,True,True]+    , Bag [True,True,True,True,True,True,True,True,True,True,True]+    ]+  , ...+  ]++map length (tiers :: [[ Bag Bool ]])  =  [1,2,3,4,5,6,7,8,9,10,11,12,...]++length (list :: [ Bag Bool ])  =  Infinity++allUnique (list :: [ Bag Bool ])  =  True++ratioRepetitions (list :: [ Bag Bool ])  =  0 % 1

+ tests/diff/tiers-BagNat.out view

@@ -0,0 +1,216 @@+tiers :: [Bag Nat]  =+  [ [Bag []]+  , [Bag [0]]+  , [ Bag [0,0]+    , Bag [1]+    ]+  , [ Bag [0,0,0]+    , Bag [0,1]+    , Bag [2]+    ]+  , [ Bag [0,0,0,0]+    , Bag [0,0,1]+    , Bag [0,2]+    , Bag [1,1]+    , Bag [3]+    ]+  , [ Bag [0,0,0,0,0]+    , Bag [0,0,0,1]+    , Bag [0,0,2]+    , Bag [0,1,1]+    , Bag [0,3]+    , Bag [1,2]+    , Bag [4]+    ]+  , [ Bag [0,0,0,0,0,0]+    , Bag [0,0,0,0,1]+    , Bag [0,0,0,2]+    , Bag [0,0,1,1]+    , Bag [0,0,3]+    , Bag [0,1,2]+    , Bag [0,4]+    , Bag [1,1,1]+    , Bag [1,3]+    , Bag [2,2]+    , Bag [5]+    ]+  , [ Bag [0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,1]+    , Bag [0,0,0,0,2]+    , Bag [0,0,0,1,1]+    , Bag [0,0,0,3]+    , Bag [0,0,1,2]+    , Bag [0,0,4]+    , Bag [0,1,1,1]+    , Bag [0,1,3]+    , Bag [0,2,2]+    , Bag [0,5]+    , Bag [1,1,2]+    , Bag [1,4]+    , Bag [2,3]+    , Bag [6]+    ]+  , [ Bag [0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,2]+    , Bag [0,0,0,0,1,1]+    , Bag [0,0,0,0,3]+    , Bag [0,0,0,1,2]+    , Bag [0,0,0,4]+    , Bag [0,0,1,1,1]+    , Bag [0,0,1,3]+    , Bag [0,0,2,2]+    , Bag [0,0,5]+    , Bag [0,1,1,2]+    , Bag [0,1,4]+    , Bag [0,2,3]+    , Bag [0,6]+    , Bag [1,1,1,1]+    , Bag [1,1,3]+    , Bag [1,2,2]+    , Bag [1,5]+    , Bag [2,4]+    , Bag [3,3]+    , Bag [7]+    ]+  , [ Bag [0,0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,0,2]+    , Bag [0,0,0,0,0,1,1]+    , Bag [0,0,0,0,0,3]+    , Bag [0,0,0,0,1,2]+    , Bag [0,0,0,0,4]+    , Bag [0,0,0,1,1,1]+    , Bag [0,0,0,1,3]+    , Bag [0,0,0,2,2]+    , Bag [0,0,0,5]+    , Bag [0,0,1,1,2]+    , Bag [0,0,1,4]+    , Bag [0,0,2,3]+    , Bag [0,0,6]+    , Bag [0,1,1,1,1]+    , Bag [0,1,1,3]+    , Bag [0,1,2,2]+    , Bag [0,1,5]+    , Bag [0,2,4]+    , Bag [0,3,3]+    , Bag [0,7]+    , Bag [1,1,1,2]+    , Bag [1,1,4]+    , Bag [1,2,3]+    , Bag [1,6]+    , Bag [2,2,2]+    , Bag [2,5]+    , Bag [3,4]+    , Bag [8]+    ]+  , [ Bag [0,0,0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,0,0,2]+    , Bag [0,0,0,0,0,0,1,1]+    , Bag [0,0,0,0,0,0,3]+    , Bag [0,0,0,0,0,1,2]+    , Bag [0,0,0,0,0,4]+    , Bag [0,0,0,0,1,1,1]+    , Bag [0,0,0,0,1,3]+    , Bag [0,0,0,0,2,2]+    , Bag [0,0,0,0,5]+    , Bag [0,0,0,1,1,2]+    , Bag [0,0,0,1,4]+    , Bag [0,0,0,2,3]+    , Bag [0,0,0,6]+    , Bag [0,0,1,1,1,1]+    , Bag [0,0,1,1,3]+    , Bag [0,0,1,2,2]+    , Bag [0,0,1,5]+    , Bag [0,0,2,4]+    , Bag [0,0,3,3]+    , Bag [0,0,7]+    , Bag [0,1,1,1,2]+    , Bag [0,1,1,4]+    , Bag [0,1,2,3]+    , Bag [0,1,6]+    , Bag [0,2,2,2]+    , Bag [0,2,5]+    , Bag [0,3,4]+    , Bag [0,8]+    , Bag [1,1,1,1,1]+    , Bag [1,1,1,3]+    , Bag [1,1,2,2]+    , Bag [1,1,5]+    , Bag [1,2,4]+    , Bag [1,3,3]+    , Bag [1,7]+    , Bag [2,2,3]+    , Bag [2,6]+    , Bag [3,5]+    , Bag [4,4]+    , Bag [9]+    ]+  , [ Bag [0,0,0,0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,0,0,0,2]+    , Bag [0,0,0,0,0,0,0,1,1]+    , Bag [0,0,0,0,0,0,0,3]+    , Bag [0,0,0,0,0,0,1,2]+    , Bag [0,0,0,0,0,0,4]+    , Bag [0,0,0,0,0,1,1,1]+    , Bag [0,0,0,0,0,1,3]+    , Bag [0,0,0,0,0,2,2]+    , Bag [0,0,0,0,0,5]+    , Bag [0,0,0,0,1,1,2]+    , Bag [0,0,0,0,1,4]+    , Bag [0,0,0,0,2,3]+    , Bag [0,0,0,0,6]+    , Bag [0,0,0,1,1,1,1]+    , Bag [0,0,0,1,1,3]+    , Bag [0,0,0,1,2,2]+    , Bag [0,0,0,1,5]+    , Bag [0,0,0,2,4]+    , Bag [0,0,0,3,3]+    , Bag [0,0,0,7]+    , Bag [0,0,1,1,1,2]+    , Bag [0,0,1,1,4]+    , Bag [0,0,1,2,3]+    , Bag [0,0,1,6]+    , Bag [0,0,2,2,2]+    , Bag [0,0,2,5]+    , Bag [0,0,3,4]+    , Bag [0,0,8]+    , Bag [0,1,1,1,1,1]+    , Bag [0,1,1,1,3]+    , Bag [0,1,1,2,2]+    , Bag [0,1,1,5]+    , Bag [0,1,2,4]+    , Bag [0,1,3,3]+    , Bag [0,1,7]+    , Bag [0,2,2,3]+    , Bag [0,2,6]+    , Bag [0,3,5]+    , Bag [0,4,4]+    , Bag [0,9]+    , Bag [1,1,1,1,2]+    , Bag [1,1,1,4]+    , Bag [1,1,2,3]+    , Bag [1,1,6]+    , Bag [1,2,2,2]+    , Bag [1,2,5]+    , Bag [1,3,4]+    , Bag [1,8]+    , Bag [2,2,4]+    , Bag [2,3,3]+    , Bag [2,7]+    , Bag [3,6]+    , Bag [4,5]+    , Bag [10]+    ]+  , ...+  ]++map length (tiers :: [[ Bag Nat ]])  =  [1,1,2,3,5,7,11,15,22,30,42,56,...]++length (list :: [ Bag Nat ])  =  Infinity++allUnique (list :: [ Bag Nat ])  =  True++ratioRepetitions (list :: [ Bag Nat ])  =  0 % 1

+ tests/diff/tiers-BagNat2.out view

@@ -0,0 +1,63 @@+tiers :: [Bag Nat2]  =+  [ [Bag []]+  , [Bag [0]]+  , [ Bag [0,0]+    , Bag [1]+    ]+  , [ Bag [0,0,0]+    , Bag [0,1]+    ]+  , [ Bag [0,0,0,0]+    , Bag [0,0,1]+    , Bag [1,1]+    ]+  , [ Bag [0,0,0,0,0]+    , Bag [0,0,0,1]+    , Bag [0,1,1]+    ]+  , [ Bag [0,0,0,0,0,0]+    , Bag [0,0,0,0,1]+    , Bag [0,0,1,1]+    , Bag [1,1,1]+    ]+  , [ Bag [0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,1]+    , Bag [0,0,0,1,1]+    , Bag [0,1,1,1]+    ]+  , [ Bag [0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,1]+    , Bag [0,0,0,0,1,1]+    , Bag [0,0,1,1,1]+    , Bag [1,1,1,1]+    ]+  , [ Bag [0,0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,1,1]+    , Bag [0,0,0,1,1,1]+    , Bag [0,1,1,1,1]+    ]+  , [ Bag [0,0,0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,0,1,1]+    , Bag [0,0,0,0,1,1,1]+    , Bag [0,0,1,1,1,1]+    , Bag [1,1,1,1,1]+    ]+  , [ Bag [0,0,0,0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,0,0,1,1]+    , Bag [0,0,0,0,0,1,1,1]+    , Bag [0,0,0,1,1,1,1]+    , Bag [0,1,1,1,1,1]+    ]+  , ...+  ]++map length (tiers :: [[ Bag Nat2 ]])  =  [1,1,2,2,3,3,4,4,5,5,6,6,...]++length (list :: [ Bag Nat2 ])  =  Infinity++allUnique (list :: [ Bag Nat2 ])  =  True++ratioRepetitions (list :: [ Bag Nat2 ])  =  0 % 1

+ tests/diff/tiers-BagNat3.out view

@@ -0,0 +1,104 @@+tiers :: [Bag Nat3]  =+  [ [Bag []]+  , [Bag [0]]+  , [ Bag [0,0]+    , Bag [1]+    ]+  , [ Bag [0,0,0]+    , Bag [0,1]+    , Bag [2]+    ]+  , [ Bag [0,0,0,0]+    , Bag [0,0,1]+    , Bag [0,2]+    , Bag [1,1]+    ]+  , [ Bag [0,0,0,0,0]+    , Bag [0,0,0,1]+    , Bag [0,0,2]+    , Bag [0,1,1]+    , Bag [1,2]+    ]+  , [ Bag [0,0,0,0,0,0]+    , Bag [0,0,0,0,1]+    , Bag [0,0,0,2]+    , Bag [0,0,1,1]+    , Bag [0,1,2]+    , Bag [1,1,1]+    , Bag [2,2]+    ]+  , [ Bag [0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,1]+    , Bag [0,0,0,0,2]+    , Bag [0,0,0,1,1]+    , Bag [0,0,1,2]+    , Bag [0,1,1,1]+    , Bag [0,2,2]+    , Bag [1,1,2]+    ]+  , [ Bag [0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,2]+    , Bag [0,0,0,0,1,1]+    , Bag [0,0,0,1,2]+    , Bag [0,0,1,1,1]+    , Bag [0,0,2,2]+    , Bag [0,1,1,2]+    , Bag [1,1,1,1]+    , Bag [1,2,2]+    ]+  , [ Bag [0,0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,0,2]+    , Bag [0,0,0,0,0,1,1]+    , Bag [0,0,0,0,1,2]+    , Bag [0,0,0,1,1,1]+    , Bag [0,0,0,2,2]+    , Bag [0,0,1,1,2]+    , Bag [0,1,1,1,1]+    , Bag [0,1,2,2]+    , Bag [1,1,1,2]+    , Bag [2,2,2]+    ]+  , [ Bag [0,0,0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,0,0,2]+    , Bag [0,0,0,0,0,0,1,1]+    , Bag [0,0,0,0,0,1,2]+    , Bag [0,0,0,0,1,1,1]+    , Bag [0,0,0,0,2,2]+    , Bag [0,0,0,1,1,2]+    , Bag [0,0,1,1,1,1]+    , Bag [0,0,1,2,2]+    , Bag [0,1,1,1,2]+    , Bag [0,2,2,2]+    , Bag [1,1,1,1,1]+    , Bag [1,1,2,2]+    ]+  , [ Bag [0,0,0,0,0,0,0,0,0,0,0]+    , Bag [0,0,0,0,0,0,0,0,0,1]+    , Bag [0,0,0,0,0,0,0,0,2]+    , Bag [0,0,0,0,0,0,0,1,1]+    , Bag [0,0,0,0,0,0,1,2]+    , Bag [0,0,0,0,0,1,1,1]+    , Bag [0,0,0,0,0,2,2]+    , Bag [0,0,0,0,1,1,2]+    , Bag [0,0,0,1,1,1,1]+    , Bag [0,0,0,1,2,2]+    , Bag [0,0,1,1,1,2]+    , Bag [0,0,2,2,2]+    , Bag [0,1,1,1,1,1]+    , Bag [0,1,1,2,2]+    , Bag [1,1,1,1,2]+    , Bag [1,2,2,2]+    ]+  , ...+  ]++map length (tiers :: [[ Bag Nat3 ]])  =  [1,1,2,3,4,5,7,8,10,12,14,16,...]++length (list :: [ Bag Nat3 ])  =  Infinity++allUnique (list :: [ Bag Nat3 ])  =  True++ratioRepetitions (list :: [ Bag Nat3 ])  =  0 % 1

+ tests/diff/tiers-BagU.out view

@@ -0,0 +1,23 @@+tiers :: [Bag ()]  =+  [ [Bag []]+  , [Bag [()]]+  , [Bag [(),()]]+  , [Bag [(),(),()]]+  , [Bag [(),(),(),()]]+  , [Bag [(),(),(),(),()]]+  , [Bag [(),(),(),(),(),()]]+  , [Bag [(),(),(),(),(),(),()]]+  , [Bag [(),(),(),(),(),(),(),()]]+  , [Bag [(),(),(),(),(),(),(),(),()]]+  , [Bag [(),(),(),(),(),(),(),(),(),()]]+  , [Bag [(),(),(),(),(),(),(),(),(),(),()]]+  , ...+  ]++map length (tiers :: [[ Bag () ]])  =  [1,1,1,1,1,1,1,1,1,1,1,1,...]++length (list :: [ Bag () ])  =  Infinity++allUnique (list :: [ Bag () ])  =  True++ratioRepetitions (list :: [ Bag () ])  =  0 % 1

+ tests/diff/tiers-Bool.out view

@@ -0,0 +1,13 @@+tiers :: [Bool]  =+  [ [ False+    , True+    ]+  ]++map length (tiers :: [[ Bool ]])  =  [2]++length (list :: [ Bool ])  =  2++allUnique (list :: [ Bool ])  =  True++ratioRepetitions (list :: [ Bool ])  =  0 % 1

+ tests/diff/tiers-Bools.out view

@@ -0,0 +1,79 @@+tiers :: [[Bool]]  =+  [ [[]]+  , [ [False]+    , [True]+    ]+  , [ [False,False]+    , [False,True]+    , [True,False]+    , [True,True]+    ]+  , [ [False,False,False]+    , [False,False,True]+    , [False,True,False]+    , [False,True,True]+    , [True,False,False]+    , [True,False,True]+    , [True,True,False]+    , [True,True,True]+    ]+  , [ [False,False,False,False]+    , [False,False,False,True]+    , [False,False,True,False]+    , [False,False,True,True]+    , [False,True,False,False]+    , [False,True,False,True]+    , [False,True,True,False]+    , [False,True,True,True]+    , [True,False,False,False]+    , [True,False,False,True]+    , [True,False,True,False]+    , [True,False,True,True]+    , [True,True,False,False]+    , [True,True,False,True]+    , [True,True,True,False]+    , [True,True,True,True]+    ]+  , [ [False,False,False,False,False]+    , [False,False,False,False,True]+    , [False,False,False,True,False]+    , [False,False,False,True,True]+    , [False,False,True,False,False]+    , [False,False,True,False,True]+    , [False,False,True,True,False]+    , [False,False,True,True,True]+    , [False,True,False,False,False]+    , [False,True,False,False,True]+    , [False,True,False,True,False]+    , [False,True,False,True,True]+    , [False,True,True,False,False]+    , [False,True,True,False,True]+    , [False,True,True,True,False]+    , [False,True,True,True,True]+    , [True,False,False,False,False]+    , [True,False,False,False,True]+    , [True,False,False,True,False]+    , [True,False,False,True,True]+    , [True,False,True,False,False]+    , [True,False,True,False,True]+    , [True,False,True,True,False]+    , [True,False,True,True,True]+    , [True,True,False,False,False]+    , [True,True,False,False,True]+    , [True,True,False,True,False]+    , [True,True,False,True,True]+    , [True,True,True,False,False]+    , [True,True,True,False,True]+    , [True,True,True,True,False]+    , [True,True,True,True,True]+    ]+  , ...+  ]++map length (tiers :: [[ [Bool] ]])  =  [1,2,4,8,16,32,...]++length (list :: [ [Bool] ])  =  Infinity++allUnique (list :: [ [Bool] ])  =  True++ratioRepetitions (list :: [ [Bool] ])  =  0 % 1

+ tests/diff/tiers-Char.out view

@@ -0,0 +1,23 @@+tiers :: [Char]  =+  [ ['a']+  , [' ']+  , ['b']+  , ['A']+  , ['c']+  , ['\n']+  , ['d']+  , ['0']+  , ['e']+  , ['B']+  , ['f']+  , ['!']+  , ...+  ]++map length (tiers :: [[ Char ]])  =  [1,1,1,1,1,1,1,1,1,1,1,1,...]++length (list :: [ Char ])  =  Infinity++allUnique (list :: [ Char ])  =  True++ratioRepetitions (list :: [ Char ])  =  0 % 1

+ tests/diff/tiers-Int,Int,Int.out view

@@ -0,0 +1,72 @@+tiers :: [(Int,Int,Int)]  =+  [ [(0,0,0)]+  , [ (0,0,1)+    , (0,1,0)+    , (1,0,0)+    ]+  , [ (0,0,-1)+    , (0,1,1)+    , (0,-1,0)+    , (1,0,1)+    , (1,1,0)+    , (-1,0,0)+    ]+  , [ (0,0,2)+    , (0,1,-1)+    , (0,-1,1)+    , (0,2,0)+    , (1,0,-1)+    , (1,1,1)+    , (1,-1,0)+    , (-1,0,1)+    , (-1,1,0)+    , (2,0,0)+    ]+  , [ (0,0,-2)+    , (0,1,2)+    , (0,-1,-1)+    , (0,2,1)+    , (0,-2,0)+    , (1,0,2)+    , (1,1,-1)+    , (1,-1,1)+    , (1,2,0)+    , (-1,0,-1)+    , (-1,1,1)+    , (-1,-1,0)+    , (2,0,1)+    , (2,1,0)+    , (-2,0,0)+    ]+  , [ (0,0,3)+    , (0,1,-2)+    , (0,-1,2)+    , (0,2,-1)+    , (0,-2,1)+    , (0,3,0)+    , (1,0,-2)+    , (1,1,2)+    , (1,-1,-1)+    , (1,2,1)+    , (1,-2,0)+    , (-1,0,2)+    , (-1,1,-1)+    , (-1,-1,1)+    , (-1,2,0)+    , (2,0,-1)+    , (2,1,1)+    , (2,-1,0)+    , (-2,0,1)+    , (-2,1,0)+    , (3,0,0)+    ]+  , ...+  ]++map length (tiers :: [[ (Int,Int,Int) ]])  =  [1,3,6,10,15,21,...]++length (list :: [ (Int,Int,Int) ])  =  Infinity++allUnique (list :: [ (Int,Int,Int) ])  =  True++ratioRepetitions (list :: [ (Int,Int,Int) ])  =  0 % 1

+ tests/diff/tiers-Int,Int.out view

@@ -0,0 +1,100 @@+tiers :: [(Int,Int)]  =+  [ [(0,0)]+  , [ (0,1)+    , (1,0)+    ]+  , [ (0,-1)+    , (1,1)+    , (-1,0)+    ]+  , [ (0,2)+    , (1,-1)+    , (-1,1)+    , (2,0)+    ]+  , [ (0,-2)+    , (1,2)+    , (-1,-1)+    , (2,1)+    , (-2,0)+    ]+  , [ (0,3)+    , (1,-2)+    , (-1,2)+    , (2,-1)+    , (-2,1)+    , (3,0)+    ]+  , [ (0,-3)+    , (1,3)+    , (-1,-2)+    , (2,2)+    , (-2,-1)+    , (3,1)+    , (-3,0)+    ]+  , [ (0,4)+    , (1,-3)+    , (-1,3)+    , (2,-2)+    , (-2,2)+    , (3,-1)+    , (-3,1)+    , (4,0)+    ]+  , [ (0,-4)+    , (1,4)+    , (-1,-3)+    , (2,3)+    , (-2,-2)+    , (3,2)+    , (-3,-1)+    , (4,1)+    , (-4,0)+    ]+  , [ (0,5)+    , (1,-4)+    , (-1,4)+    , (2,-3)+    , (-2,3)+    , (3,-2)+    , (-3,2)+    , (4,-1)+    , (-4,1)+    , (5,0)+    ]+  , [ (0,-5)+    , (1,5)+    , (-1,-4)+    , (2,4)+    , (-2,-3)+    , (3,3)+    , (-3,-2)+    , (4,2)+    , (-4,-1)+    , (5,1)+    , (-5,0)+    ]+  , [ (0,6)+    , (1,-5)+    , (-1,5)+    , (2,-4)+    , (-2,4)+    , (3,-3)+    , (-3,3)+    , (4,-2)+    , (-4,2)+    , (5,-1)+    , (-5,1)+    , (6,0)+    ]+  , ...+  ]++map length (tiers :: [[ (Int,Int) ]])  =  [1,2,3,4,5,6,7,8,9,10,11,12,...]++length (list :: [ (Int,Int) ])  =  Infinity++allUnique (list :: [ (Int,Int) ])  =  True++ratioRepetitions (list :: [ (Int,Int) ])  =  0 % 1

+ tests/diff/tiers-Int.out view

@@ -0,0 +1,23 @@+tiers :: [Int]  =+  [ [0]+  , [1]+  , [-1]+  , [2]+  , [-2]+  , [3]+  , [-3]+  , [4]+  , [-4]+  , [5]+  , [-5]+  , [6]+  , ...+  ]++map length (tiers :: [[ Int ]])  =  [1,1,1,1,1,1,1,1,1,1,1,1,...]++length (list :: [ Int ])  =  Infinity++allUnique (list :: [ Int ])  =  True++ratioRepetitions (list :: [ Int ])  =  0 % 1

+ tests/diff/tiers-Integer.out view

@@ -0,0 +1,23 @@+tiers :: [Integer]  =+  [ [0]+  , [1]+  , [-1]+  , [2]+  , [-2]+  , [3]+  , [-3]+  , [4]+  , [-4]+  , [5]+  , [-5]+  , [6]+  , ...+  ]++map length (tiers :: [[ Integer ]])  =  [1,1,1,1,1,1,1,1,1,1,1,1,...]++length (list :: [ Integer ])  =  Infinity++allUnique (list :: [ Integer ])  =  True++ratioRepetitions (list :: [ Integer ])  =  0 % 1

+ tests/diff/tiers-Ints.out view

@@ -0,0 +1,47 @@+tiers :: [[Int]]  =+  [ [[]]+  , [[0]]+  , [ [0,0]+    , [1]+    ]+  , [ [0,0,0]+    , [0,1]+    , [1,0]+    , [-1]+    ]+  , [ [0,0,0,0]+    , [0,0,1]+    , [0,1,0]+    , [0,-1]+    , [1,0,0]+    , [1,1]+    , [-1,0]+    , [2]+    ]+  , [ [0,0,0,0,0]+    , [0,0,0,1]+    , [0,0,1,0]+    , [0,0,-1]+    , [0,1,0,0]+    , [0,1,1]+    , [0,-1,0]+    , [0,2]+    , [1,0,0,0]+    , [1,0,1]+    , [1,1,0]+    , [1,-1]+    , [-1,0,0]+    , [-1,1]+    , [2,0]+    , [-2]+    ]+  , ...+  ]++map length (tiers :: [[ [Int] ]])  =  [1,1,2,4,8,16,...]++length (list :: [ [Int] ])  =  Infinity++allUnique (list :: [ [Int] ])  =  True++ratioRepetitions (list :: [ [Int] ])  =  0 % 1

+ tests/diff/tiers-Nat,Nat,Nat.out view

@@ -0,0 +1,72 @@+tiers :: [(Nat,Nat,Nat)]  =+  [ [(0,0,0)]+  , [ (0,0,1)+    , (0,1,0)+    , (1,0,0)+    ]+  , [ (0,0,2)+    , (0,1,1)+    , (0,2,0)+    , (1,0,1)+    , (1,1,0)+    , (2,0,0)+    ]+  , [ (0,0,3)+    , (0,1,2)+    , (0,2,1)+    , (0,3,0)+    , (1,0,2)+    , (1,1,1)+    , (1,2,0)+    , (2,0,1)+    , (2,1,0)+    , (3,0,0)+    ]+  , [ (0,0,4)+    , (0,1,3)+    , (0,2,2)+    , (0,3,1)+    , (0,4,0)+    , (1,0,3)+    , (1,1,2)+    , (1,2,1)+    , (1,3,0)+    , (2,0,2)+    , (2,1,1)+    , (2,2,0)+    , (3,0,1)+    , (3,1,0)+    , (4,0,0)+    ]+  , [ (0,0,5)+    , (0,1,4)+    , (0,2,3)+    , (0,3,2)+    , (0,4,1)+    , (0,5,0)+    , (1,0,4)+    , (1,1,3)+    , (1,2,2)+    , (1,3,1)+    , (1,4,0)+    , (2,0,3)+    , (2,1,2)+    , (2,2,1)+    , (2,3,0)+    , (3,0,2)+    , (3,1,1)+    , (3,2,0)+    , (4,0,1)+    , (4,1,0)+    , (5,0,0)+    ]+  , ...+  ]++map length (tiers :: [[ (Nat,Nat,Nat) ]])  =  [1,3,6,10,15,21,...]++length (list :: [ (Nat,Nat,Nat) ])  =  Infinity++allUnique (list :: [ (Nat,Nat,Nat) ])  =  True++ratioRepetitions (list :: [ (Nat,Nat,Nat) ])  =  0 % 1

+ tests/diff/tiers-Nat,Nat.out view

@@ -0,0 +1,100 @@+tiers :: [(Nat,Nat)]  =+  [ [(0,0)]+  , [ (0,1)+    , (1,0)+    ]+  , [ (0,2)+    , (1,1)+    , (2,0)+    ]+  , [ (0,3)+    , (1,2)+    , (2,1)+    , (3,0)+    ]+  , [ (0,4)+    , (1,3)+    , (2,2)+    , (3,1)+    , (4,0)+    ]+  , [ (0,5)+    , (1,4)+    , (2,3)+    , (3,2)+    , (4,1)+    , (5,0)+    ]+  , [ (0,6)+    , (1,5)+    , (2,4)+    , (3,3)+    , (4,2)+    , (5,1)+    , (6,0)+    ]+  , [ (0,7)+    , (1,6)+    , (2,5)+    , (3,4)+    , (4,3)+    , (5,2)+    , (6,1)+    , (7,0)+    ]+  , [ (0,8)+    , (1,7)+    , (2,6)+    , (3,5)+    , (4,4)+    , (5,3)+    , (6,2)+    , (7,1)+    , (8,0)+    ]+  , [ (0,9)+    , (1,8)+    , (2,7)+    , (3,6)+    , (4,5)+    , (5,4)+    , (6,3)+    , (7,2)+    , (8,1)+    , (9,0)+    ]+  , [ (0,10)+    , (1,9)+    , (2,8)+    , (3,7)+    , (4,6)+    , (5,5)+    , (6,4)+    , (7,3)+    , (8,2)+    , (9,1)+    , (10,0)+    ]+  , [ (0,11)+    , (1,10)+    , (2,9)+    , (3,8)+    , (4,7)+    , (5,6)+    , (6,5)+    , (7,4)+    , (8,3)+    , (9,2)+    , (10,1)+    , (11,0)+    ]+  , ...+  ]++map length (tiers :: [[ (Nat,Nat) ]])  =  [1,2,3,4,5,6,7,8,9,10,11,12,...]++length (list :: [ (Nat,Nat) ])  =  Infinity++allUnique (list :: [ (Nat,Nat) ])  =  True++ratioRepetitions (list :: [ (Nat,Nat) ])  =  0 % 1

+ tests/diff/tiers-Nat.out view

@@ -0,0 +1,23 @@+tiers :: [Nat]  =+  [ [0]+  , [1]+  , [2]+  , [3]+  , [4]+  , [5]+  , [6]+  , [7]+  , [8]+  , [9]+  , [10]+  , [11]+  , ...+  ]++map length (tiers :: [[ Nat ]])  =  [1,1,1,1,1,1,1,1,1,1,1,1,...]++length (list :: [ Nat ])  =  Infinity++allUnique (list :: [ Nat ])  =  True++ratioRepetitions (list :: [ Nat ])  =  0 % 1

+ tests/diff/tiers-Nats.out view

@@ -0,0 +1,47 @@+tiers :: [[Nat]]  =+  [ [[]]+  , [[0]]+  , [ [0,0]+    , [1]+    ]+  , [ [0,0,0]+    , [0,1]+    , [1,0]+    , [2]+    ]+  , [ [0,0,0,0]+    , [0,0,1]+    , [0,1,0]+    , [0,2]+    , [1,0,0]+    , [1,1]+    , [2,0]+    , [3]+    ]+  , [ [0,0,0,0,0]+    , [0,0,0,1]+    , [0,0,1,0]+    , [0,0,2]+    , [0,1,0,0]+    , [0,1,1]+    , [0,2,0]+    , [0,3]+    , [1,0,0,0]+    , [1,0,1]+    , [1,1,0]+    , [1,2]+    , [2,0,0]+    , [2,1]+    , [3,0]+    , [4]+    ]+  , ...+  ]++map length (tiers :: [[ [Nat] ]])  =  [1,1,2,4,8,16,...]++length (list :: [ [Nat] ])  =  Infinity++allUnique (list :: [ [Nat] ])  =  True++ratioRepetitions (list :: [ [Nat] ])  =  0 % 1

+ tests/diff/tiers-NoDupBool.out view

@@ -0,0 +1,17 @@+tiers :: [NoDup Bool]  =+  [ [NoDup []]+  , [ NoDup [False]+    , NoDup [True]+    ]+  , [ NoDup [False,True]+    , NoDup [True,False]+    ]+  ]++map length (tiers :: [[ NoDup Bool ]])  =  [1,2,2]++length (list :: [ NoDup Bool ])  =  5++allUnique (list :: [ NoDup Bool ])  =  True++ratioRepetitions (list :: [ NoDup Bool ])  =  0 % 1

+ tests/diff/tiers-NoDupNat.out view

@@ -0,0 +1,226 @@+tiers :: [NoDup Nat]  =+  [ [NoDup []]+  , [NoDup [0]]+  , [NoDup [1]]+  , [ NoDup [0,1]+    , NoDup [1,0]+    , NoDup [2]+    ]+  , [ NoDup [0,2]+    , NoDup [2,0]+    , NoDup [3]+    ]+  , [ NoDup [0,3]+    , NoDup [1,2]+    , NoDup [2,1]+    , NoDup [3,0]+    , NoDup [4]+    ]+  , [ NoDup [0,1,2]+    , NoDup [0,2,1]+    , NoDup [0,4]+    , NoDup [1,0,2]+    , NoDup [1,2,0]+    , NoDup [1,3]+    , NoDup [2,0,1]+    , NoDup [2,1,0]+    , NoDup [3,1]+    , NoDup [4,0]+    , NoDup [5]+    ]+  , [ NoDup [0,1,3]+    , NoDup [0,3,1]+    , NoDup [0,5]+    , NoDup [1,0,3]+    , NoDup [1,3,0]+    , NoDup [1,4]+    , NoDup [2,3]+    , NoDup [3,0,1]+    , NoDup [3,1,0]+    , NoDup [3,2]+    , NoDup [4,1]+    , NoDup [5,0]+    , NoDup [6]+    ]+  , [ NoDup [0,1,4]+    , NoDup [0,2,3]+    , NoDup [0,3,2]+    , NoDup [0,4,1]+    , NoDup [0,6]+    , NoDup [1,0,4]+    , NoDup [1,4,0]+    , NoDup [1,5]+    , NoDup [2,0,3]+    , NoDup [2,3,0]+    , NoDup [2,4]+    , NoDup [3,0,2]+    , NoDup [3,2,0]+    , NoDup [4,0,1]+    , NoDup [4,1,0]+    , NoDup [4,2]+    , NoDup [5,1]+    , NoDup [6,0]+    , NoDup [7]+    ]+  , [ NoDup [0,1,5]+    , NoDup [0,2,4]+    , NoDup [0,4,2]+    , NoDup [0,5,1]+    , NoDup [0,7]+    , NoDup [1,0,5]+    , NoDup [1,2,3]+    , NoDup [1,3,2]+    , NoDup [1,5,0]+    , NoDup [1,6]+    , NoDup [2,0,4]+    , NoDup [2,1,3]+    , NoDup [2,3,1]+    , NoDup [2,4,0]+    , NoDup [2,5]+    , NoDup [3,1,2]+    , NoDup [3,2,1]+    , NoDup [3,4]+    , NoDup [4,0,2]+    , NoDup [4,2,0]+    , NoDup [4,3]+    , NoDup [5,0,1]+    , NoDup [5,1,0]+    , NoDup [5,2]+    , NoDup [6,1]+    , NoDup [7,0]+    , NoDup [8]+    ]+  , [ NoDup [0,1,2,3]+    , NoDup [0,1,3,2]+    , NoDup [0,1,6]+    , NoDup [0,2,1,3]+    , NoDup [0,2,3,1]+    , NoDup [0,2,5]+    , NoDup [0,3,1,2]+    , NoDup [0,3,2,1]+    , NoDup [0,3,4]+    , NoDup [0,4,3]+    , NoDup [0,5,2]+    , NoDup [0,6,1]+    , NoDup [0,8]+    , NoDup [1,0,2,3]+    , NoDup [1,0,3,2]+    , NoDup [1,0,6]+    , NoDup [1,2,0,3]+    , NoDup [1,2,3,0]+    , NoDup [1,2,4]+    , NoDup [1,3,0,2]+    , NoDup [1,3,2,0]+    , NoDup [1,4,2]+    , NoDup [1,6,0]+    , NoDup [1,7]+    , NoDup [2,0,1,3]+    , NoDup [2,0,3,1]+    , NoDup [2,0,5]+    , NoDup [2,1,0,3]+    , NoDup [2,1,3,0]+    , NoDup [2,1,4]+    , NoDup [2,3,0,1]+    , NoDup [2,3,1,0]+    , NoDup [2,4,1]+    , NoDup [2,5,0]+    , NoDup [2,6]+    , NoDup [3,0,1,2]+    , NoDup [3,0,2,1]+    , NoDup [3,0,4]+    , NoDup [3,1,0,2]+    , NoDup [3,1,2,0]+    , NoDup [3,2,0,1]+    , NoDup [3,2,1,0]+    , NoDup [3,4,0]+    , NoDup [3,5]+    , NoDup [4,0,3]+    , NoDup [4,1,2]+    , NoDup [4,2,1]+    , NoDup [4,3,0]+    , NoDup [5,0,2]+    , NoDup [5,2,0]+    , NoDup [5,3]+    , NoDup [6,0,1]+    , NoDup [6,1,0]+    , NoDup [6,2]+    , NoDup [7,1]+    , NoDup [8,0]+    , NoDup [9]+    ]+  , [ NoDup [0,1,2,4]+    , NoDup [0,1,4,2]+    , NoDup [0,1,7]+    , NoDup [0,2,1,4]+    , NoDup [0,2,4,1]+    , NoDup [0,2,6]+    , NoDup [0,3,5]+    , NoDup [0,4,1,2]+    , NoDup [0,4,2,1]+    , NoDup [0,5,3]+    , NoDup [0,6,2]+    , NoDup [0,7,1]+    , NoDup [0,9]+    , NoDup [1,0,2,4]+    , NoDup [1,0,4,2]+    , NoDup [1,0,7]+    , NoDup [1,2,0,4]+    , NoDup [1,2,4,0]+    , NoDup [1,2,5]+    , NoDup [1,3,4]+    , NoDup [1,4,0,2]+    , NoDup [1,4,2,0]+    , NoDup [1,4,3]+    , NoDup [1,5,2]+    , NoDup [1,7,0]+    , NoDup [1,8]+    , NoDup [2,0,1,4]+    , NoDup [2,0,4,1]+    , NoDup [2,0,6]+    , NoDup [2,1,0,4]+    , NoDup [2,1,4,0]+    , NoDup [2,1,5]+    , NoDup [2,4,0,1]+    , NoDup [2,4,1,0]+    , NoDup [2,5,1]+    , NoDup [2,6,0]+    , NoDup [2,7]+    , NoDup [3,0,5]+    , NoDup [3,1,4]+    , NoDup [3,4,1]+    , NoDup [3,5,0]+    , NoDup [3,6]+    , NoDup [4,0,1,2]+    , NoDup [4,0,2,1]+    , NoDup [4,1,0,2]+    , NoDup [4,1,2,0]+    , NoDup [4,1,3]+    , NoDup [4,2,0,1]+    , NoDup [4,2,1,0]+    , NoDup [4,3,1]+    , NoDup [4,5]+    , NoDup [5,0,3]+    , NoDup [5,1,2]+    , NoDup [5,2,1]+    , NoDup [5,3,0]+    , NoDup [5,4]+    , NoDup [6,0,2]+    , NoDup [6,2,0]+    , NoDup [6,3]+    , NoDup [7,0,1]+    , NoDup [7,1,0]+    , NoDup [7,2]+    , NoDup [8,1]+    , NoDup [9,0]+    , NoDup [10]+    ]+  , ...+  ]++map length (tiers :: [[ NoDup Nat ]])  =  [1,1,1,3,3,5,11,13,19,27,57,65,...]++length (list :: [ NoDup Nat ])  =  Infinity++allUnique (list :: [ NoDup Nat ])  =  True++ratioRepetitions (list :: [ NoDup Nat ])  =  0 % 1

+ tests/diff/tiers-NoDupNat2.out view

@@ -0,0 +1,16 @@+tiers :: [NoDup Nat2]  =+  [ [NoDup []]+  , [NoDup [0]]+  , [NoDup [1]]+  , [ NoDup [0,1]+    , NoDup [1,0]+    ]+  ]++map length (tiers :: [[ NoDup Nat2 ]])  =  [1,1,1,2]++length (list :: [ NoDup Nat2 ])  =  5++allUnique (list :: [ NoDup Nat2 ])  =  True++ratioRepetitions (list :: [ NoDup Nat2 ])  =  0 % 1

+ tests/diff/tiers-NoDupNat3.out view

@@ -0,0 +1,30 @@+tiers :: [NoDup Nat3]  =+  [ [NoDup []]+  , [NoDup [0]]+  , [NoDup [1]]+  , [ NoDup [0,1]+    , NoDup [1,0]+    , NoDup [2]+    ]+  , [ NoDup [0,2]+    , NoDup [2,0]+    ]+  , [ NoDup [1,2]+    , NoDup [2,1]+    ]+  , [ NoDup [0,1,2]+    , NoDup [0,2,1]+    , NoDup [1,0,2]+    , NoDup [1,2,0]+    , NoDup [2,0,1]+    , NoDup [2,1,0]+    ]+  ]++map length (tiers :: [[ NoDup Nat3 ]])  =  [1,1,1,3,2,2,6]++length (list :: [ NoDup Nat3 ])  =  Infinity++allUnique (list :: [ NoDup Nat3 ])  =  True++ratioRepetitions (list :: [ NoDup Nat3 ])  =  0 % 1

+ tests/diff/tiers-NoDupU.out view

@@ -0,0 +1,12 @@+tiers :: [NoDup ()]  =+  [ [NoDup []]+  , [NoDup [()]]+  ]++map length (tiers :: [[ NoDup () ]])  =  [1,1]++length (list :: [ NoDup () ])  =  2++allUnique (list :: [ NoDup () ])  =  True++ratioRepetitions (list :: [ NoDup () ])  =  0 % 1

+ tests/diff/tiers-SetBool.out view

@@ -0,0 +1,15 @@+tiers :: [Set Bool]  =+  [ [Set []]+  , [ Set [False]+    , Set [True]+    ]+  , [Set [False,True]]+  ]++map length (tiers :: [[ Set Bool ]])  =  [1,2,1]++length (list :: [ Set Bool ])  =  4++allUnique (list :: [ Set Bool ])  =  True++ratioRepetitions (list :: [ Set Bool ])  =  0 % 1

+ tests/diff/tiers-SetNat.out view

@@ -0,0 +1,75 @@+tiers :: [Set Nat]  =+  [ [Set []]+  , [Set [0]]+  , [Set [1]]+  , [ Set [0,1]+    , Set [2]+    ]+  , [ Set [0,2]+    , Set [3]+    ]+  , [ Set [0,3]+    , Set [1,2]+    , Set [4]+    ]+  , [ Set [0,1,2]+    , Set [0,4]+    , Set [1,3]+    , Set [5]+    ]+  , [ Set [0,1,3]+    , Set [0,5]+    , Set [1,4]+    , Set [2,3]+    , Set [6]+    ]+  , [ Set [0,1,4]+    , Set [0,2,3]+    , Set [0,6]+    , Set [1,5]+    , Set [2,4]+    , Set [7]+    ]+  , [ Set [0,1,5]+    , Set [0,2,4]+    , Set [0,7]+    , Set [1,2,3]+    , Set [1,6]+    , Set [2,5]+    , Set [3,4]+    , Set [8]+    ]+  , [ Set [0,1,2,3]+    , Set [0,1,6]+    , Set [0,2,5]+    , Set [0,3,4]+    , Set [0,8]+    , Set [1,2,4]+    , Set [1,7]+    , Set [2,6]+    , Set [3,5]+    , Set [9]+    ]+  , [ Set [0,1,2,4]+    , Set [0,1,7]+    , Set [0,2,6]+    , Set [0,3,5]+    , Set [0,9]+    , Set [1,2,5]+    , Set [1,3,4]+    , Set [1,8]+    , Set [2,7]+    , Set [3,6]+    , Set [4,5]+    , Set [10]+    ]+  , ...+  ]++map length (tiers :: [[ Set Nat ]])  =  [1,1,1,2,2,3,4,5,6,8,10,12,...]++length (list :: [ Set Nat ])  =  Infinity++allUnique (list :: [ Set Nat ])  =  True++ratioRepetitions (list :: [ Set Nat ])  =  0 % 1

+ tests/diff/tiers-SetNat2.out view

@@ -0,0 +1,14 @@+tiers :: [Set Nat2]  =+  [ [Set []]+  , [Set [0]]+  , [Set [1]]+  , [Set [0,1]]+  ]++map length (tiers :: [[ Set Nat2 ]])  =  [1,1,1,1]++length (list :: [ Set Nat2 ])  =  4++allUnique (list :: [ Set Nat2 ])  =  True++ratioRepetitions (list :: [ Set Nat2 ])  =  0 % 1

+ tests/diff/tiers-SetNat3.out view

@@ -0,0 +1,19 @@+tiers :: [Set Nat3]  =+  [ [Set []]+  , [Set [0]]+  , [Set [1]]+  , [ Set [0,1]+    , Set [2]+    ]+  , [Set [0,2]]+  , [Set [1,2]]+  , [Set [0,1,2]]+  ]++map length (tiers :: [[ Set Nat3 ]])  =  [1,1,1,2,1,1,1]++length (list :: [ Set Nat3 ])  =  8++allUnique (list :: [ Set Nat3 ])  =  True++ratioRepetitions (list :: [ Set Nat3 ])  =  0 % 1

+ tests/diff/tiers-SetU.out view

@@ -0,0 +1,12 @@+tiers :: [Set ()]  =+  [ [Set []]+  , [Set [()]]+  ]++map length (tiers :: [[ Set () ]])  =  [1,1]++length (list :: [ Set () ])  =  2++allUnique (list :: [ Set () ])  =  True++ratioRepetitions (list :: [ Set () ])  =  0 % 1

+ tests/diff/tiers-String.out view

@@ -0,0 +1,47 @@+tiers :: [String]  =+  [ [""]+  , ["a"]+  , [ "aa"+    , " "+    ]+  , [ "aaa"+    , "a "+    , " a"+    , "b"+    ]+  , [ "aaaa"+    , "aa "+    , "a a"+    , "ab"+    , " aa"+    , "  "+    , "ba"+    , "A"+    ]+  , [ "aaaaa"+    , "aaa "+    , "aa a"+    , "aab"+    , "a aa"+    , "a  "+    , "aba"+    , "aA"+    , " aaa"+    , " a "+    , "  a"+    , " b"+    , "baa"+    , "b "+    , "Aa"+    , "c"+    ]+  , ...+  ]++map length (tiers :: [[ String ]])  =  [1,1,2,4,8,16,...]++length (list :: [ String ])  =  Infinity++allUnique (list :: [ String ])  =  True++ratioRepetitions (list :: [ String ])  =  0 % 1

+ tests/diff/tiers-U,Us.out view

@@ -0,0 +1,23 @@+tiers :: [[((),())]]  =+  [ [[]]+  , [[((),())]]+  , [[((),()),((),())]]+  , [[((),()),((),()),((),())]]+  , [[((),()),((),()),((),()),((),())]]+  , [[((),()),((),()),((),()),((),()),((),())]]+  , [[((),()),((),()),((),()),((),()),((),()),((),())]]+  , [[((),()),((),()),((),()),((),()),((),()),((),()),((),())]]+  , [[((),()),((),()),((),()),((),()),((),()),((),()),((),()),((),())]]+  , [[((),()),((),()),((),()),((),()),((),()),((),()),((),()),((),()),((),())]]+  , [[((),()),((),()),((),()),((),()),((),()),((),()),((),()),((),()),((),()),((),())]]+  , [[((),()),((),()),((),()),((),()),((),()),((),()),((),()),((),()),((),()),((),()),((),())]]+  , ...+  ]++map length (tiers :: [[ [((),())] ]])  =  [1,1,1,1,1,1,1,1,1,1,1,1,...]++length (list :: [ [((),())] ])  =  Infinity++allUnique (list :: [ [((),())] ])  =  True++ratioRepetitions (list :: [ [((),())] ])  =  0 % 1

+ tests/diff/tiers-Us,Us.out view

@@ -0,0 +1,100 @@+tiers :: [([()],[()])]  =+  [ [([],[])]+  , [ ([],[()])+    , ([()],[])+    ]+  , [ ([],[(),()])+    , ([()],[()])+    , ([(),()],[])+    ]+  , [ ([],[(),(),()])+    , ([()],[(),()])+    , ([(),()],[()])+    , ([(),(),()],[])+    ]+  , [ ([],[(),(),(),()])+    , ([()],[(),(),()])+    , ([(),()],[(),()])+    , ([(),(),()],[()])+    , ([(),(),(),()],[])+    ]+  , [ ([],[(),(),(),(),()])+    , ([()],[(),(),(),()])+    , ([(),()],[(),(),()])+    , ([(),(),()],[(),()])+    , ([(),(),(),()],[()])+    , ([(),(),(),(),()],[])+    ]+  , [ ([],[(),(),(),(),(),()])+    , ([()],[(),(),(),(),()])+    , ([(),()],[(),(),(),()])+    , ([(),(),()],[(),(),()])+    , ([(),(),(),()],[(),()])+    , ([(),(),(),(),()],[()])+    , ([(),(),(),(),(),()],[])+    ]+  , [ ([],[(),(),(),(),(),(),()])+    , ([()],[(),(),(),(),(),()])+    , ([(),()],[(),(),(),(),()])+    , ([(),(),()],[(),(),(),()])+    , ([(),(),(),()],[(),(),()])+    , ([(),(),(),(),()],[(),()])+    , ([(),(),(),(),(),()],[()])+    , ([(),(),(),(),(),(),()],[])+    ]+  , [ ([],[(),(),(),(),(),(),(),()])+    , ([()],[(),(),(),(),(),(),()])+    , ([(),()],[(),(),(),(),(),()])+    , ([(),(),()],[(),(),(),(),()])+    , ([(),(),(),()],[(),(),(),()])+    , ([(),(),(),(),()],[(),(),()])+    , ([(),(),(),(),(),()],[(),()])+    , ([(),(),(),(),(),(),()],[()])+    , ([(),(),(),(),(),(),(),()],[])+    ]+  , [ ([],[(),(),(),(),(),(),(),(),()])+    , ([()],[(),(),(),(),(),(),(),()])+    , ([(),()],[(),(),(),(),(),(),()])+    , ([(),(),()],[(),(),(),(),(),()])+    , ([(),(),(),()],[(),(),(),(),()])+    , ([(),(),(),(),()],[(),(),(),()])+    , ([(),(),(),(),(),()],[(),(),()])+    , ([(),(),(),(),(),(),()],[(),()])+    , ([(),(),(),(),(),(),(),()],[()])+    , ([(),(),(),(),(),(),(),(),()],[])+    ]+  , [ ([],[(),(),(),(),(),(),(),(),(),()])+    , ([()],[(),(),(),(),(),(),(),(),()])+    , ([(),()],[(),(),(),(),(),(),(),()])+    , ([(),(),()],[(),(),(),(),(),(),()])+    , ([(),(),(),()],[(),(),(),(),(),()])+    , ([(),(),(),(),()],[(),(),(),(),()])+    , ([(),(),(),(),(),()],[(),(),(),()])+    , ([(),(),(),(),(),(),()],[(),(),()])+    , ([(),(),(),(),(),(),(),()],[(),()])+    , ([(),(),(),(),(),(),(),(),()],[()])+    , ([(),(),(),(),(),(),(),(),(),()],[])+    ]+  , [ ([],[(),(),(),(),(),(),(),(),(),(),()])+    , ([()],[(),(),(),(),(),(),(),(),(),()])+    , ([(),()],[(),(),(),(),(),(),(),(),()])+    , ([(),(),()],[(),(),(),(),(),(),(),()])+    , ([(),(),(),()],[(),(),(),(),(),(),()])+    , ([(),(),(),(),()],[(),(),(),(),(),()])+    , ([(),(),(),(),(),()],[(),(),(),(),()])+    , ([(),(),(),(),(),(),()],[(),(),(),()])+    , ([(),(),(),(),(),(),(),()],[(),(),()])+    , ([(),(),(),(),(),(),(),(),()],[(),()])+    , ([(),(),(),(),(),(),(),(),(),()],[()])+    , ([(),(),(),(),(),(),(),(),(),(),()],[])+    ]+  , ...+  ]++map length (tiers :: [[ ([()],[()]) ]])  =  [1,2,3,4,5,6,7,8,9,10,11,12,...]++length (list :: [ ([()],[()]) ])  =  Infinity++allUnique (list :: [ ([()],[()]) ])  =  True++ratioRepetitions (list :: [ ([()],[()]) ])  =  0 % 1

+ tests/diff/tiers-Us.out view

@@ -0,0 +1,23 @@+tiers :: [[()]]  =+  [ [[]]+  , [[()]]+  , [[(),()]]+  , [[(),(),()]]+  , [[(),(),(),()]]+  , [[(),(),(),(),()]]+  , [[(),(),(),(),(),()]]+  , [[(),(),(),(),(),(),()]]+  , [[(),(),(),(),(),(),(),()]]+  , [[(),(),(),(),(),(),(),(),()]]+  , [[(),(),(),(),(),(),(),(),(),()]]+  , [[(),(),(),(),(),(),(),(),(),(),()]]+  , ...+  ]++map length (tiers :: [[ [()] ]])  =  [1,1,1,1,1,1,1,1,1,1,1,1,...]++length (list :: [ [()] ])  =  Infinity++allUnique (list :: [ [()] ])  =  True++ratioRepetitions (list :: [ [()] ])  =  0 % 1

+ tests/diff/tiers-colistable-Bool-Bool.out view

@@ -0,0 +1,23 @@+tiers :: [Bool->Bool]  =+  [ [ \x -> case x of+              False -> False+              True -> False+    , \x -> case x of+              False -> True+              True -> False+    , \x -> case x of+              False -> False+              True -> True+    , \x -> case x of+              False -> True+              True -> True+    ]+  ]++map length (tiers :: [[ Bool->Bool ]])  =  [4]++length (list :: [ Bool->Bool ])  =  4++allUnique (list :: [ Bool->Bool ])  =  True++ratioRepetitions (list :: [ Bool->Bool ])  =  0 % 1

+ tests/diff/tiers-colistable-Bool-MBool.out view

@@ -0,0 +1,40 @@+tiers :: [Bool->Maybe Bool]  =+  [ [ \x -> case x of+              False -> Nothing+              True -> Nothing+    ]+  , [ \x -> case x of+              False -> Just False+              True -> Nothing+    , \x -> case x of+              False -> Just True+              True -> Nothing+    , \x -> case x of+              False -> Nothing+              True -> Just False+    , \x -> case x of+              False -> Nothing+              True -> Just True+    ]+  , [ \x -> case x of+              False -> Just False+              True -> Just False+    , \x -> case x of+              False -> Just True+              True -> Just False+    , \x -> case x of+              False -> Just False+              True -> Just True+    , \x -> case x of+              False -> Just True+              True -> Just True+    ]+  ]++map length (tiers :: [[ Bool->Maybe Bool ]])  =  [1,4,4]++length (list :: [ Bool->Maybe Bool ])  =  9++allUnique (list :: [ Bool->Maybe Bool ])  =  True++ratioRepetitions (list :: [ Bool->Maybe Bool ])  =  0 % 1

+ tests/diff/tiers-colistable-Bool-U.out view

@@ -0,0 +1,14 @@+tiers :: [Bool->()]  =+  [ [ \x -> case x of+              False -> ()+              True -> ()+    ]+  ]++map length (tiers :: [[ Bool->() ]])  =  [1]++length (list :: [ Bool->() ])  =  1++allUnique (list :: [ Bool->() ])  =  True++ratioRepetitions (list :: [ Bool->() ])  =  0 % 1

+ tests/diff/tiers-colistable-Bools-Bools.out view

@@ -0,0 +1,745 @@+tiers :: [[Bool]->[Bool]]  =+  [ [ \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [False]+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [False,False]+              [False] -> [False,False]+              [True] -> [False,False]+              [False,False] -> [False,False]+              [False,True] -> [False,False]+              [True,False] -> [False,False]+              [True,True] -> [False,False]+              [False,False,False] -> [False,False]+              ...+    , \x -> case x of+              [] -> [False,True]+              [False] -> [False,True]+              [True] -> [False,True]+              [False,False] -> [False,True]+              [False,True] -> [False,True]+              [True,False] -> [False,True]+              [True,True] -> [False,True]+              [False,False,False] -> [False,True]+              ...+    , \x -> case x of+              [] -> [True,False]+              [False] -> [True,False]+              [True] -> [True,False]+              [False,False] -> [True,False]+              [False,True] -> [True,False]+              [True,False] -> [True,False]+              [True,True] -> [True,False]+              [False,False,False] -> [True,False]+              ...+    , \x -> case x of+              [] -> [True,True]+              [False] -> [True,True]+              [True] -> [True,True]+              [False,False] -> [True,True]+              [False,True] -> [True,True]+              [True,False] -> [True,True]+              [True,True] -> [True,True]+              [False,False,False] -> [True,True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> []+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> []+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [False,False,False]+              [False] -> [False,False,False]+              [True] -> [False,False,False]+              [False,False] -> [False,False,False]+              [False,True] -> [False,False,False]+              [True,False] -> [False,False,False]+              [True,True] -> [False,False,False]+              [False,False,False] -> [False,False,False]+              ...+    , \x -> case x of+              [] -> [False,False,True]+              [False] -> [False,False,True]+              [True] -> [False,False,True]+              [False,False] -> [False,False,True]+              [False,True] -> [False,False,True]+              [True,False] -> [False,False,True]+              [True,True] -> [False,False,True]+              [False,False,False] -> [False,False,True]+              ...+    , \x -> case x of+              [] -> [False,True,False]+              [False] -> [False,True,False]+              [True] -> [False,True,False]+              [False,False] -> [False,True,False]+              [False,True] -> [False,True,False]+              [True,False] -> [False,True,False]+              [True,True] -> [False,True,False]+              [False,False,False] -> [False,True,False]+              ...+    , \x -> case x of+              [] -> [False,True,True]+              [False] -> [False,True,True]+              [True] -> [False,True,True]+              [False,False] -> [False,True,True]+              [False,True] -> [False,True,True]+              [True,False] -> [False,True,True]+              [True,True] -> [False,True,True]+              [False,False,False] -> [False,True,True]+              ...+    , \x -> case x of+              [] -> [True,False,False]+              [False] -> [True,False,False]+              [True] -> [True,False,False]+              [False,False] -> [True,False,False]+              [False,True] -> [True,False,False]+              [True,False] -> [True,False,False]+              [True,True] -> [True,False,False]+              [False,False,False] -> [True,False,False]+              ...+    , \x -> case x of+              [] -> [True,False,True]+              [False] -> [True,False,True]+              [True] -> [True,False,True]+              [False,False] -> [True,False,True]+              [False,True] -> [True,False,True]+              [True,False] -> [True,False,True]+              [True,True] -> [True,False,True]+              [False,False,False] -> [True,False,True]+              ...+    , \x -> case x of+              [] -> [True,True,False]+              [False] -> [True,True,False]+              [True] -> [True,True,False]+              [False,False] -> [True,True,False]+              [False,True] -> [True,True,False]+              [True,False] -> [True,True,False]+              [True,True] -> [True,True,False]+              [False,False,False] -> [True,True,False]+              ...+    , \x -> case x of+              [] -> [True,True,True]+              [False] -> [True,True,True]+              [True] -> [True,True,True]+              [False,False] -> [True,True,True]+              [False,True] -> [True,True,True]+              [True,False] -> [True,True,True]+              [True,True] -> [True,True,True]+              [False,False,False] -> [True,True,True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False,False]+              [True] -> []+              [False,False] -> [False,False]+              [False,True] -> [False,False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False,False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False,True]+              [True] -> []+              [False,False] -> [False,True]+              [False,True] -> [False,True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False,True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True,False]+              [True] -> []+              [False,False] -> [True,False]+              [False,True] -> [True,False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True,False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True,True]+              [True] -> []+              [False,False] -> [True,True]+              [False,True] -> [True,True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True,True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> [False]+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> [True]+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> [False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> [True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> [False]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> [True]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> []+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> []+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False,False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False,False]+              [True,True] -> [False,False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False,True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False,True]+              [True,True] -> [False,True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True,False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True,False]+              [True,True] -> [True,False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True,True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True,True]+              [True,True] -> [True,True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False]+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True]+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> [False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> [True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> [False]+              [True] -> []+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> [True]+              [True] -> []+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [False]+              [True] -> []+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [True]+              [True] -> []+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False,False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False,True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True,False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True,True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Bool]->[Bool] ]])  =  [1,3,12,57,...]++length (list :: [ [Bool]->[Bool] ])  =  Infinity++allUnique (list :: [ [Bool]->[Bool] ])  =  False++ratioRepetitions (list :: [ [Bool]->[Bool] ])  =  16 % 73

+ tests/diff/tiers-colistable-Int-Int-Int.out view

@@ -0,0 +1,625 @@+tiers :: [Int->Int->Int]  =+  [ [ \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,-1) -> 2+                (1,1) -> 2+                (-1,0) -> 2+                (0,2) -> 2+                (1,-1) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> -1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    ]+  , ...+  ]++map length (tiers :: [[ Int->Int->Int ]])  =  [1,3,11,46,...]++length (list :: [ Int->Int->Int ])  =  Infinity++allUnique (list :: [ Int->Int->Int ])  =  False++ratioRepetitions (list :: [ Int->Int->Int ])  =  37 % 61

+ tests/diff/tiers-colistable-Int-Int.out view

@@ -0,0 +1,2637 @@+tiers :: [Int->Int]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 2+              -1 -> 2+              2 -> 2+              -2 -> 2+              3 -> 2+              -3 -> 2+              4 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> -2+              1 -> -2+              -1 -> -2+              2 -> -2+              -2 -> -2+              3 -> -2+              -3 -> -2+              4 -> -2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 2+              2 -> 0+              -2 -> 2+              3 -> 0+              -3 -> 2+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> -1+              2 -> 1+              -2 -> -1+              3 -> 1+              -3 -> -1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 1+              2 -> -1+              -2 -> 1+              3 -> -1+              -3 -> 1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              -1 -> 0+              2 -> 2+              -2 -> 0+              3 -> 2+              -3 -> 0+              4 -> 2+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 3+              1 -> 3+              -1 -> 3+              2 -> 3+              -2 -> 3+              3 -> 3+              -3 -> 3+              4 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -2+              2 -> 0+              -2 -> -2+              3 -> 0+              -3 -> -2+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 2+              3 -> 0+              -3 -> 2+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 2+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 2+              2 -> 1+              -2 -> 2+              3 -> 1+              -3 -> 2+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> -1+              3 -> 1+              -3 -> -1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> -1+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 2+              2 -> 0+              -2 -> 2+              3 -> 0+              -3 -> 2+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 1+              3 -> -1+              -3 -> 1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 1+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> -1+              2 -> 1+              -2 -> -1+              3 -> 1+              -3 -> -1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              -1 -> 1+              2 -> 2+              -2 -> 1+              3 -> 2+              -3 -> 1+              4 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              -1 -> 0+              2 -> 2+              -2 -> 0+              3 -> 2+              -3 -> 0+              4 -> 2+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 1+              2 -> -1+              -2 -> 1+              3 -> -1+              -3 -> 1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -2+              1 -> -2+              -1 -> 0+              2 -> -2+              -2 -> 0+              3 -> -2+              -3 -> 0+              4 -> -2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              -1 -> 0+              2 -> 2+              -2 -> 0+              3 -> 2+              -3 -> 0+              4 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , ...+  ]++map length (tiers :: [[ Int->Int ]])  =  [1,2,5,15,51,188,...]++length (list :: [ Int->Int ])  =  Infinity++allUnique (list :: [ Int->Int ])  =  False++ratioRepetitions (list :: [ Int->Int ])  =  96 % 131

+ tests/diff/tiers-colistable-Ints-Ints.out view

@@ -0,0 +1,315 @@+tiers :: [[Int]->[Int]]  =+  [ [ \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0]+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [-1] -> [0,0]+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [-1] -> [1]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0,0]+              [0] -> [0,0,0]+              [0,0] -> [0,0,0]+              [1] -> [0,0,0]+              [0,0,0] -> [0,0,0]+              [0,1] -> [0,0,0]+              [1,0] -> [0,0,0]+              [-1] -> [0,0,0]+              ...+    , \x -> case x of+              [] -> [0,1]+              [0] -> [0,1]+              [0,0] -> [0,1]+              [1] -> [0,1]+              [0,0,0] -> [0,1]+              [0,1] -> [0,1]+              [1,0] -> [0,1]+              [-1] -> [0,1]+              ...+    , \x -> case x of+              [] -> [1,0]+              [0] -> [1,0]+              [0,0] -> [1,0]+              [1] -> [1,0]+              [0,0,0] -> [1,0]+              [0,1] -> [1,0]+              [1,0] -> [1,0]+              [-1] -> [1,0]+              ...+    , \x -> case x of+              [] -> [-1]+              [0] -> [-1]+              [0,0] -> [-1]+              [1] -> [-1]+              [0,0,0] -> [-1]+              [0,1] -> [-1]+              [1,0] -> [-1]+              [-1] -> [-1]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [-1] -> [0,0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [-1] -> [1]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> [0]+              [1] -> []+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> []+              [1] -> [0]+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [0,0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Int]->[Int] ]])  =  [1,2,6,21,...]++length (list :: [ [Int]->[Int] ])  =  Infinity++allUnique (list :: [ [Int]->[Int] ])  =  False++ratioRepetitions (list :: [ [Int]->[Int] ])  =  2 % 5

+ tests/diff/tiers-colistable-MBool-Bool.out view

@@ -0,0 +1,43 @@+tiers :: [Maybe Bool->Bool]  =+  [ [ \x -> case x of+              Nothing -> False+              Just False -> False+              Just True -> False+    , \x -> case x of+              Nothing -> False+              Just False -> True+              Just True -> False+    , \x -> case x of+              Nothing -> False+              Just False -> False+              Just True -> True+    , \x -> case x of+              Nothing -> False+              Just False -> True+              Just True -> True+    , \x -> case x of+              Nothing -> True+              Just False -> False+              Just True -> False+    , \x -> case x of+              Nothing -> True+              Just False -> True+              Just True -> False+    , \x -> case x of+              Nothing -> True+              Just False -> False+              Just True -> True+    , \x -> case x of+              Nothing -> True+              Just False -> True+              Just True -> True+    ]+  ]++map length (tiers :: [[ Maybe Bool->Bool ]])  =  [8]++length (list :: [ Maybe Bool->Bool ])  =  8++allUnique (list :: [ Maybe Bool->Bool ])  =  True++ratioRepetitions (list :: [ Maybe Bool->Bool ])  =  0 % 1

+ tests/diff/tiers-colistable-MBool-MBool.out view

@@ -0,0 +1,122 @@+tiers :: [Maybe Bool->Maybe Bool]  =+  [ [ \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Nothing+    ]+  , [ \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Nothing+    ]+  , [ \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Just True+    ]+  , [ \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Just True+    ]+  ]++map length (tiers :: [[ Maybe Bool->Maybe Bool ]])  =  [1,6,12,8]++length (list :: [ Maybe Bool->Maybe Bool ])  =  Infinity++allUnique (list :: [ Maybe Bool->Maybe Bool ])  =  True++ratioRepetitions (list :: [ Maybe Bool->Maybe Bool ])  =  0 % 1

+ tests/diff/tiers-colistable-Nat,Nat-Nat.out view

@@ -0,0 +1,625 @@+tiers :: [(Nat,Nat)->Nat]  =+  [ [ \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    ]+  , [ \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    ]+  , [ \x -> case x of+              (0,0) -> 2+              (0,1) -> 2+              (1,0) -> 2+              (0,2) -> 2+              (1,1) -> 2+              (2,0) -> 2+              (0,3) -> 2+              (1,2) -> 2+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    ]+  , [ \x -> case x of+              (0,0) -> 3+              (0,1) -> 3+              (1,0) -> 3+              (0,2) -> 3+              (1,1) -> 3+              (2,0) -> 3+              (0,3) -> 3+              (1,2) -> 3+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 2+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 2+              (2,0) -> 0+              (0,3) -> 2+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 2+              (0,1) -> 0+              (1,0) -> 2+              (0,2) -> 2+              (1,1) -> 0+              (2,0) -> 2+              (0,3) -> 0+              (1,2) -> 2+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 2+              (0,2) -> 0+              (1,1) -> 2+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 2+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 2+              (0,1) -> 2+              (1,0) -> 0+              (0,2) -> 2+              (1,1) -> 0+              (2,0) -> 2+              (0,3) -> 2+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    ]+  , ...+  ]++map length (tiers :: [[ (Nat,Nat)->Nat ]])  =  [1,3,11,46,...]++length (list :: [ (Nat,Nat)->Nat ])  =  Infinity++allUnique (list :: [ (Nat,Nat)->Nat ])  =  False++ratioRepetitions (list :: [ (Nat,Nat)->Nat ])  =  37 % 61

+ tests/diff/tiers-colistable-Nat-Nat-Nat.out view

@@ -0,0 +1,625 @@+tiers :: [Nat->Nat->Nat]  =+  [ [ \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,2) -> 2+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 3+                (0,1) -> 3+                (1,0) -> 3+                (0,2) -> 3+                (1,1) -> 3+                (2,0) -> 3+                (0,3) -> 3+                (1,2) -> 3+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    ]+  , ...+  ]++map length (tiers :: [[ Nat->Nat->Nat ]])  =  [1,3,11,46,...]++length (list :: [ Nat->Nat->Nat ])  =  Infinity++allUnique (list :: [ Nat->Nat->Nat ])  =  False++ratioRepetitions (list :: [ Nat->Nat->Nat ])  =  37 % 61

+ tests/diff/tiers-colistable-Nat-Nat.out view

@@ -0,0 +1,2637 @@+tiers :: [Nat->Nat]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 3+              1 -> 3+              2 -> 3+              3 -> 3+              4 -> 3+              5 -> 3+              6 -> 3+              7 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 4+              1 -> 4+              2 -> 4+              3 -> 4+              4 -> 4+              5 -> 4+              6 -> 4+              7 -> 4+              ...+    , \x -> case x of+              0 -> 0+              1 -> 3+              2 -> 0+              3 -> 3+              4 -> 0+              5 -> 3+              6 -> 0+              7 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 1+              3 -> 2+              4 -> 1+              5 -> 2+              6 -> 1+              7 -> 2+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 2+              3 -> 1+              4 -> 2+              5 -> 1+              6 -> 2+              7 -> 1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 3+              1 -> 0+              2 -> 3+              3 -> 0+              4 -> 3+              5 -> 0+              6 -> 3+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 5+              1 -> 5+              2 -> 5+              3 -> 5+              4 -> 5+              5 -> 5+              6 -> 5+              7 -> 5+              ...+    , \x -> case x of+              0 -> 0+              1 -> 4+              2 -> 0+              3 -> 4+              4 -> 0+              5 -> 4+              6 -> 0+              7 -> 4+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 3+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 3+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 3+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 3+              2 -> 1+              3 -> 3+              4 -> 1+              5 -> 3+              6 -> 1+              7 -> 3+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 2+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 2+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 2+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 3+              2 -> 0+              3 -> 3+              4 -> 0+              5 -> 3+              6 -> 0+              7 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 1+              4 -> 2+              5 -> 0+              6 -> 2+              7 -> 1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 2+              3 -> 0+              4 -> 2+              5 -> 1+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 1+              3 -> 2+              4 -> 0+              5 -> 2+              6 -> 1+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 1+              5 -> 2+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 3+              1 -> 1+              2 -> 3+              3 -> 1+              4 -> 3+              5 -> 1+              6 -> 3+              7 -> 1+              ...+    , \x -> case x of+              0 -> 3+              1 -> 0+              2 -> 3+              3 -> 0+              4 -> 3+              5 -> 0+              6 -> 3+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 2+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 2+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 2+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 4+              1 -> 0+              2 -> 4+              3 -> 0+              4 -> 4+              5 -> 0+              6 -> 4+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 3+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 3+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 3+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 3+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , ...+  ]++map length (tiers :: [[ Nat->Nat ]])  =  [1,2,5,15,51,188,...]++length (list :: [ Nat->Nat ])  =  Infinity++allUnique (list :: [ Nat->Nat ])  =  False++ratioRepetitions (list :: [ Nat->Nat ])  =  82 % 131

+ tests/diff/tiers-colistable-Nat-U.out view

@@ -0,0 +1,667 @@+tiers :: [Nat->()]  =+  [ [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , ...+  ]++map length (tiers :: [[ Nat->() ]])  =  [1,1,2,5,14,42,...]++length (list :: [ Nat->() ])  =  Infinity++allUnique (list :: [ Nat->() ])  =  False++ratioRepetitions (list :: [ Nat->() ])  =  64 % 65

+ tests/diff/tiers-colistable-Nat2-Nat2.out view

@@ -0,0 +1,25 @@+tiers :: [Nat2->Nat2]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+    ]+  ]++map length (tiers :: [[ Nat2->Nat2 ]])  =  [1,2,1]++length (list :: [ Nat2->Nat2 ])  =  4++allUnique (list :: [ Nat2->Nat2 ])  =  True++ratioRepetitions (list :: [ Nat2->Nat2 ])  =  0 % 1

+ tests/diff/tiers-colistable-Nat2-Nat3.out view

@@ -0,0 +1,42 @@+tiers :: [Nat2->Nat3]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 2+    ]+  ]++map length (tiers :: [[ Nat2->Nat3 ]])  =  [1,2,3,2,1]++length (list :: [ Nat2->Nat3 ])  =  9++allUnique (list :: [ Nat2->Nat3 ])  =  True++ratioRepetitions (list :: [ Nat2->Nat3 ])  =  0 % 1

+ tests/diff/tiers-colistable-Nat3-Nat2.out view

@@ -0,0 +1,46 @@+tiers :: [Nat3->Nat2]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+    ]+  ]++map length (tiers :: [[ Nat3->Nat2 ]])  =  [1,3,3,1]++length (list :: [ Nat3->Nat2 ])  =  8++allUnique (list :: [ Nat3->Nat2 ])  =  True++ratioRepetitions (list :: [ Nat3->Nat2 ])  =  0 % 1

+ tests/diff/tiers-colistable-Nat3-Nat3.out view

@@ -0,0 +1,125 @@+tiers :: [Nat3->Nat3]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 0+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 1+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 2+    ]+  ]++map length (tiers :: [[ Nat3->Nat3 ]])  =  [1,3,6,7,6,3,1]++length (list :: [ Nat3->Nat3 ])  =  Infinity++allUnique (list :: [ Nat3->Nat3 ])  =  True++ratioRepetitions (list :: [ Nat3->Nat3 ])  =  0 % 1

+ tests/diff/tiers-colistable-Nats-Nats.out view

@@ -0,0 +1,315 @@+tiers :: [[Nat]->[Nat]]  =+  [ [ \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0]+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [2] -> [0,0]+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [2] -> [1]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0,0]+              [0] -> [0,0,0]+              [0,0] -> [0,0,0]+              [1] -> [0,0,0]+              [0,0,0] -> [0,0,0]+              [0,1] -> [0,0,0]+              [1,0] -> [0,0,0]+              [2] -> [0,0,0]+              ...+    , \x -> case x of+              [] -> [0,1]+              [0] -> [0,1]+              [0,0] -> [0,1]+              [1] -> [0,1]+              [0,0,0] -> [0,1]+              [0,1] -> [0,1]+              [1,0] -> [0,1]+              [2] -> [0,1]+              ...+    , \x -> case x of+              [] -> [1,0]+              [0] -> [1,0]+              [0,0] -> [1,0]+              [1] -> [1,0]+              [0,0,0] -> [1,0]+              [0,1] -> [1,0]+              [1,0] -> [1,0]+              [2] -> [1,0]+              ...+    , \x -> case x of+              [] -> [2]+              [0] -> [2]+              [0,0] -> [2]+              [1] -> [2]+              [0,0,0] -> [2]+              [0,1] -> [2]+              [1,0] -> [2]+              [2] -> [2]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [2] -> [0,0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [2] -> [1]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> [0]+              [1] -> []+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> []+              [1] -> [0]+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> [0]+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> [0]+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> []+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> []+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [0,0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Nat]->[Nat] ]])  =  [1,2,6,21,...]++length (list :: [ [Nat]->[Nat] ])  =  Infinity++allUnique (list :: [ [Nat]->[Nat] ])  =  False++ratioRepetitions (list :: [ [Nat]->[Nat] ])  =  2 % 5

+ tests/diff/tiers-colistable-U-Bool.out view

@@ -0,0 +1,15 @@+tiers :: [()->Bool]  =+  [ [ \x -> case x of+              () -> False+    , \x -> case x of+              () -> True+    ]+  ]++map length (tiers :: [[ ()->Bool ]])  =  [2]++length (list :: [ ()->Bool ])  =  2++allUnique (list :: [ ()->Bool ])  =  True++ratioRepetitions (list :: [ ()->Bool ])  =  0 % 1

+ tests/diff/tiers-colistable-U-Nat.out view

@@ -0,0 +1,29 @@+tiers :: [()->Nat]  =+  [ [ \x -> case x of+              () -> 0+    ]+  , [ \x -> case x of+              () -> 1+    ]+  , [ \x -> case x of+              () -> 2+    ]+  , [ \x -> case x of+              () -> 3+    ]+  , [ \x -> case x of+              () -> 4+    ]+  , [ \x -> case x of+              () -> 5+    ]+  , ...+  ]++map length (tiers :: [[ ()->Nat ]])  =  [1,1,1,1,1,1,...]++length (list :: [ ()->Nat ])  =  Infinity++allUnique (list :: [ ()->Nat ])  =  True++ratioRepetitions (list :: [ ()->Nat ])  =  0 % 1

+ tests/diff/tiers-colistable-U-U.out view

@@ -0,0 +1,13 @@+tiers :: [()->()]  =+  [ [ \x -> case x of+              () -> ()+    ]+  ]++map length (tiers :: [[ ()->() ]])  =  [1]++length (list :: [ ()->() ])  =  1++allUnique (list :: [ ()->() ])  =  True++ratioRepetitions (list :: [ ()->() ])  =  0 % 1

+ tests/diff/tiers-colistable-Us-Us.out view

@@ -0,0 +1,165 @@+tiers :: [[()]->[()]]  =+  [ [ \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [()]+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [(),()]+              [()] -> [(),()]+              [(),()] -> [(),()]+              [(),(),()] -> [(),()]+              [(),(),(),()] -> [(),()]+              [(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),(),()] -> [(),()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> [()]+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [(),(),()]+              [()] -> [(),(),()]+              [(),()] -> [(),(),()]+              [(),(),()] -> [(),(),()]+              [(),(),(),()] -> [(),(),()]+              [(),(),(),(),()] -> [(),(),()]+              [(),(),(),(),(),()] -> [(),(),()]+              [(),(),(),(),(),(),()] -> [(),(),()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> [(),()]+              [(),()] -> [(),()]+              [(),(),()] -> [(),()]+              [(),(),(),()] -> [(),()]+              [(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),(),()] -> [(),()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> []+              [()] -> [()]+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> [()]+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> [()]+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> [(),()]+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [()]->[()] ]])  =  [1,2,4,8,...]++length (list :: [ [()]->[()] ])  =  Infinity++allUnique (list :: [ [()]->[()] ])  =  False++ratioRepetitions (list :: [ [()]->[()] ])  =  1 % 3

+ tests/diff/tiers-funlistable-Bool-Bool.out view

@@ -0,0 +1,23 @@+tiers :: [Bool->Bool]  =+  [ [ \x -> case x of+              False -> False+              True -> False+    , \x -> case x of+              False -> True+              True -> False+    , \x -> case x of+              False -> False+              True -> True+    , \x -> case x of+              False -> True+              True -> True+    ]+  ]++map length (tiers :: [[ Bool->Bool ]])  =  [4]++length (list :: [ Bool->Bool ])  =  4++allUnique (list :: [ Bool->Bool ])  =  True++ratioRepetitions (list :: [ Bool->Bool ])  =  0 % 1

+ tests/diff/tiers-funlistable-Bool-MBool.out view

@@ -0,0 +1,40 @@+tiers :: [Bool->Maybe Bool]  =+  [ [ \x -> case x of+              False -> Nothing+              True -> Nothing+    ]+  , [ \x -> case x of+              False -> Just False+              True -> Nothing+    , \x -> case x of+              False -> Just True+              True -> Nothing+    , \x -> case x of+              False -> Nothing+              True -> Just False+    , \x -> case x of+              False -> Nothing+              True -> Just True+    ]+  , [ \x -> case x of+              False -> Just False+              True -> Just False+    , \x -> case x of+              False -> Just True+              True -> Just False+    , \x -> case x of+              False -> Just False+              True -> Just True+    , \x -> case x of+              False -> Just True+              True -> Just True+    ]+  ]++map length (tiers :: [[ Bool->Maybe Bool ]])  =  [1,4,4]++length (list :: [ Bool->Maybe Bool ])  =  9++allUnique (list :: [ Bool->Maybe Bool ])  =  True++ratioRepetitions (list :: [ Bool->Maybe Bool ])  =  0 % 1

+ tests/diff/tiers-funlistable-Bool-U.out view

@@ -0,0 +1,14 @@+tiers :: [Bool->()]  =+  [ [ \x -> case x of+              False -> ()+              True -> ()+    ]+  ]++map length (tiers :: [[ Bool->() ]])  =  [1]++length (list :: [ Bool->() ])  =  1++allUnique (list :: [ Bool->() ])  =  True++ratioRepetitions (list :: [ Bool->() ])  =  0 % 1

+ tests/diff/tiers-funlistable-Bools-Bools.out view

@@ -0,0 +1,165 @@+tiers :: [[Bool]->[Bool]]  =+  [ [ \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [False]+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    ]+  , [ \x -> case x of+              [] -> [False,False]+              [False] -> [False,False]+              [True] -> [False,False]+              [False,False] -> [False,False]+              [False,True] -> [False,False]+              [True,False] -> [False,False]+              [True,True] -> [False,False]+              [False,False,False] -> [False,False]+              ...+    , \x -> case x of+              [] -> [False,True]+              [False] -> [False,True]+              [True] -> [False,True]+              [False,False] -> [False,True]+              [False,True] -> [False,True]+              [True,False] -> [False,True]+              [True,True] -> [False,True]+              [False,False,False] -> [False,True]+              ...+    , \x -> case x of+              [] -> [True,False]+              [False] -> [True,False]+              [True] -> [True,False]+              [False,False] -> [True,False]+              [False,True] -> [True,False]+              [True,False] -> [True,False]+              [True,True] -> [True,False]+              [False,False,False] -> [True,False]+              ...+    , \x -> case x of+              [] -> [True,True]+              [False] -> [True,True]+              [True] -> [True,True]+              [False,False] -> [True,True]+              [False,True] -> [True,True]+              [True,False] -> [True,True]+              [True,True] -> [True,True]+              [False,False,False] -> [True,True]+              ...+    ]+  , [ \x -> case x of+              [] -> [False,False,False]+              [False] -> [False,False,False]+              [True] -> [False,False,False]+              [False,False] -> [False,False,False]+              [False,True] -> [False,False,False]+              [True,False] -> [False,False,False]+              [True,True] -> [False,False,False]+              [False,False,False] -> [False,False,False]+              ...+    , \x -> case x of+              [] -> [False,False,True]+              [False] -> [False,False,True]+              [True] -> [False,False,True]+              [False,False] -> [False,False,True]+              [False,True] -> [False,False,True]+              [True,False] -> [False,False,True]+              [True,True] -> [False,False,True]+              [False,False,False] -> [False,False,True]+              ...+    , \x -> case x of+              [] -> [False,True,False]+              [False] -> [False,True,False]+              [True] -> [False,True,False]+              [False,False] -> [False,True,False]+              [False,True] -> [False,True,False]+              [True,False] -> [False,True,False]+              [True,True] -> [False,True,False]+              [False,False,False] -> [False,True,False]+              ...+    , \x -> case x of+              [] -> [False,True,True]+              [False] -> [False,True,True]+              [True] -> [False,True,True]+              [False,False] -> [False,True,True]+              [False,True] -> [False,True,True]+              [True,False] -> [False,True,True]+              [True,True] -> [False,True,True]+              [False,False,False] -> [False,True,True]+              ...+    , \x -> case x of+              [] -> [True,False,False]+              [False] -> [True,False,False]+              [True] -> [True,False,False]+              [False,False] -> [True,False,False]+              [False,True] -> [True,False,False]+              [True,False] -> [True,False,False]+              [True,True] -> [True,False,False]+              [False,False,False] -> [True,False,False]+              ...+    , \x -> case x of+              [] -> [True,False,True]+              [False] -> [True,False,True]+              [True] -> [True,False,True]+              [False,False] -> [True,False,True]+              [False,True] -> [True,False,True]+              [True,False] -> [True,False,True]+              [True,True] -> [True,False,True]+              [False,False,False] -> [True,False,True]+              ...+    , \x -> case x of+              [] -> [True,True,False]+              [False] -> [True,True,False]+              [True] -> [True,True,False]+              [False,False] -> [True,True,False]+              [False,True] -> [True,True,False]+              [True,False] -> [True,True,False]+              [True,True] -> [True,True,False]+              [False,False,False] -> [True,True,False]+              ...+    , \x -> case x of+              [] -> [True,True,True]+              [False] -> [True,True,True]+              [True] -> [True,True,True]+              [False,False] -> [True,True,True]+              [False,True] -> [True,True,True]+              [True,False] -> [True,True,True]+              [True,True] -> [True,True,True]+              [False,False,False] -> [True,True,True]+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Bool]->[Bool] ]])  =  [1,2,4,8,...]++length (list :: [ [Bool]->[Bool] ])  =  Infinity++allUnique (list :: [ [Bool]->[Bool] ])  =  True++ratioRepetitions (list :: [ [Bool]->[Bool] ])  =  0 % 1

+ tests/diff/tiers-funlistable-Int-Int-Int.out view

@@ -0,0 +1,10 @@+tiers :: [Int->Int->Int]  =+  [[]]++map length (tiers :: [[ Int->Int->Int ]])  =  [0]++length (list :: [ Int->Int->Int ])  =  0++allUnique (list :: [ Int->Int->Int ])  =  True++ratioRepetitions (list :: [ Int->Int->Int ])  =  0 % 1

+ tests/diff/tiers-funlistable-Int-Int.out view

@@ -0,0 +1,10 @@+tiers :: [Int->Int]  =+  [[]]++map length (tiers :: [[ Int->Int ]])  =  [0]++length (list :: [ Int->Int ])  =  0++allUnique (list :: [ Int->Int ])  =  True++ratioRepetitions (list :: [ Int->Int ])  =  0 % 1

+ tests/diff/tiers-funlistable-Ints-Ints.out view

@@ -0,0 +1,95 @@+tiers :: [[Int]->[Int]]  =+  [ [ \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0]+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [-1] -> [0,0]+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [-1] -> [1]+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0,0]+              [0] -> [0,0,0]+              [0,0] -> [0,0,0]+              [1] -> [0,0,0]+              [0,0,0] -> [0,0,0]+              [0,1] -> [0,0,0]+              [1,0] -> [0,0,0]+              [-1] -> [0,0,0]+              ...+    , \x -> case x of+              [] -> [0,1]+              [0] -> [0,1]+              [0,0] -> [0,1]+              [1] -> [0,1]+              [0,0,0] -> [0,1]+              [0,1] -> [0,1]+              [1,0] -> [0,1]+              [-1] -> [0,1]+              ...+    , \x -> case x of+              [] -> [1,0]+              [0] -> [1,0]+              [0,0] -> [1,0]+              [1] -> [1,0]+              [0,0,0] -> [1,0]+              [0,1] -> [1,0]+              [1,0] -> [1,0]+              [-1] -> [1,0]+              ...+    , \x -> case x of+              [] -> [-1]+              [0] -> [-1]+              [0,0] -> [-1]+              [1] -> [-1]+              [0,0,0] -> [-1]+              [0,1] -> [-1]+              [1,0] -> [-1]+              [-1] -> [-1]+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Int]->[Int] ]])  =  [1,1,2,4,...]++length (list :: [ [Int]->[Int] ])  =  Infinity++allUnique (list :: [ [Int]->[Int] ])  =  True++ratioRepetitions (list :: [ [Int]->[Int] ])  =  0 % 1

+ tests/diff/tiers-funlistable-MBool-Bool.out view

@@ -0,0 +1,43 @@+tiers :: [Maybe Bool->Bool]  =+  [ [ \x -> case x of+              Nothing -> False+              Just False -> False+              Just True -> False+    , \x -> case x of+              Nothing -> False+              Just False -> True+              Just True -> False+    , \x -> case x of+              Nothing -> False+              Just False -> False+              Just True -> True+    , \x -> case x of+              Nothing -> False+              Just False -> True+              Just True -> True+    , \x -> case x of+              Nothing -> True+              Just False -> False+              Just True -> False+    , \x -> case x of+              Nothing -> True+              Just False -> True+              Just True -> False+    , \x -> case x of+              Nothing -> True+              Just False -> False+              Just True -> True+    , \x -> case x of+              Nothing -> True+              Just False -> True+              Just True -> True+    ]+  ]++map length (tiers :: [[ Maybe Bool->Bool ]])  =  [8]++length (list :: [ Maybe Bool->Bool ])  =  8++allUnique (list :: [ Maybe Bool->Bool ])  =  True++ratioRepetitions (list :: [ Maybe Bool->Bool ])  =  0 % 1

+ tests/diff/tiers-funlistable-MBool-MBool.out view

@@ -0,0 +1,122 @@+tiers :: [Maybe Bool->Maybe Bool]  =+  [ [ \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Nothing+    ]+  , [ \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Nothing+    ]+  , [ \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Just True+    ]+  , [ \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Just True+    ]+  ]++map length (tiers :: [[ Maybe Bool->Maybe Bool ]])  =  [1,6,12,8]++length (list :: [ Maybe Bool->Maybe Bool ])  =  Infinity++allUnique (list :: [ Maybe Bool->Maybe Bool ])  =  True++ratioRepetitions (list :: [ Maybe Bool->Maybe Bool ])  =  0 % 1

+ tests/diff/tiers-funlistable-Nat,Nat-Nat.out view

@@ -0,0 +1,10 @@+tiers :: [(Nat,Nat)->Nat]  =+  [[]]++map length (tiers :: [[ (Nat,Nat)->Nat ]])  =  [0]++length (list :: [ (Nat,Nat)->Nat ])  =  0++allUnique (list :: [ (Nat,Nat)->Nat ])  =  True++ratioRepetitions (list :: [ (Nat,Nat)->Nat ])  =  0 % 1

+ tests/diff/tiers-funlistable-Nat-Nat-Nat.out view

@@ -0,0 +1,10 @@+tiers :: [Nat->Nat->Nat]  =+  [[]]++map length (tiers :: [[ Nat->Nat->Nat ]])  =  [0]++length (list :: [ Nat->Nat->Nat ])  =  0++allUnique (list :: [ Nat->Nat->Nat ])  =  True++ratioRepetitions (list :: [ Nat->Nat->Nat ])  =  0 % 1

+ tests/diff/tiers-funlistable-Nat-Nat.out view

@@ -0,0 +1,10 @@+tiers :: [Nat->Nat]  =+  [[]]++map length (tiers :: [[ Nat->Nat ]])  =  [0]++length (list :: [ Nat->Nat ])  =  0++allUnique (list :: [ Nat->Nat ])  =  True++ratioRepetitions (list :: [ Nat->Nat ])  =  0 % 1

+ tests/diff/tiers-funlistable-Nat-U.out view

@@ -0,0 +1,10 @@+tiers :: [Nat->()]  =+  [[]]++map length (tiers :: [[ Nat->() ]])  =  [0]++length (list :: [ Nat->() ])  =  0++allUnique (list :: [ Nat->() ])  =  True++ratioRepetitions (list :: [ Nat->() ])  =  0 % 1

+ tests/diff/tiers-funlistable-Nat2-Nat2.out view

@@ -0,0 +1,10 @@+tiers :: [Nat2->Nat2]  =+  [[]]++map length (tiers :: [[ Nat2->Nat2 ]])  =  [0]++length (list :: [ Nat2->Nat2 ])  =  0++allUnique (list :: [ Nat2->Nat2 ])  =  True++ratioRepetitions (list :: [ Nat2->Nat2 ])  =  0 % 1

+ tests/diff/tiers-funlistable-Nat2-Nat3.out view

@@ -0,0 +1,10 @@+tiers :: [Nat2->Nat3]  =+  [[]]++map length (tiers :: [[ Nat2->Nat3 ]])  =  [0]++length (list :: [ Nat2->Nat3 ])  =  0++allUnique (list :: [ Nat2->Nat3 ])  =  True++ratioRepetitions (list :: [ Nat2->Nat3 ])  =  0 % 1

+ tests/diff/tiers-funlistable-Nat3-Nat2.out view

@@ -0,0 +1,10 @@+tiers :: [Nat3->Nat2]  =+  [[]]++map length (tiers :: [[ Nat3->Nat2 ]])  =  [0]++length (list :: [ Nat3->Nat2 ])  =  0++allUnique (list :: [ Nat3->Nat2 ])  =  True++ratioRepetitions (list :: [ Nat3->Nat2 ])  =  0 % 1

+ tests/diff/tiers-funlistable-Nat3-Nat3.out view

@@ -0,0 +1,10 @@+tiers :: [Nat3->Nat3]  =+  [[]]++map length (tiers :: [[ Nat3->Nat3 ]])  =  [0]++length (list :: [ Nat3->Nat3 ])  =  0++allUnique (list :: [ Nat3->Nat3 ])  =  True++ratioRepetitions (list :: [ Nat3->Nat3 ])  =  0 % 1

+ tests/diff/tiers-funlistable-Nats-Nats.out view

@@ -0,0 +1,95 @@+tiers :: [[Nat]->[Nat]]  =+  [ [ \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0]+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [2] -> [0,0]+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [2] -> [1]+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0,0]+              [0] -> [0,0,0]+              [0,0] -> [0,0,0]+              [1] -> [0,0,0]+              [0,0,0] -> [0,0,0]+              [0,1] -> [0,0,0]+              [1,0] -> [0,0,0]+              [2] -> [0,0,0]+              ...+    , \x -> case x of+              [] -> [0,1]+              [0] -> [0,1]+              [0,0] -> [0,1]+              [1] -> [0,1]+              [0,0,0] -> [0,1]+              [0,1] -> [0,1]+              [1,0] -> [0,1]+              [2] -> [0,1]+              ...+    , \x -> case x of+              [] -> [1,0]+              [0] -> [1,0]+              [0,0] -> [1,0]+              [1] -> [1,0]+              [0,0,0] -> [1,0]+              [0,1] -> [1,0]+              [1,0] -> [1,0]+              [2] -> [1,0]+              ...+    , \x -> case x of+              [] -> [2]+              [0] -> [2]+              [0,0] -> [2]+              [1] -> [2]+              [0,0,0] -> [2]+              [0,1] -> [2]+              [1,0] -> [2]+              [2] -> [2]+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Nat]->[Nat] ]])  =  [1,1,2,4,...]++length (list :: [ [Nat]->[Nat] ])  =  Infinity++allUnique (list :: [ [Nat]->[Nat] ])  =  True++ratioRepetitions (list :: [ [Nat]->[Nat] ])  =  0 % 1

+ tests/diff/tiers-funlistable-U-Bool.out view

@@ -0,0 +1,15 @@+tiers :: [()->Bool]  =+  [ [ \x -> case x of+              () -> False+    , \x -> case x of+              () -> True+    ]+  ]++map length (tiers :: [[ ()->Bool ]])  =  [2]++length (list :: [ ()->Bool ])  =  2++allUnique (list :: [ ()->Bool ])  =  True++ratioRepetitions (list :: [ ()->Bool ])  =  0 % 1

+ tests/diff/tiers-funlistable-U-Nat.out view

@@ -0,0 +1,29 @@+tiers :: [()->Nat]  =+  [ [ \x -> case x of+              () -> 0+    ]+  , [ \x -> case x of+              () -> 1+    ]+  , [ \x -> case x of+              () -> 2+    ]+  , [ \x -> case x of+              () -> 3+    ]+  , [ \x -> case x of+              () -> 4+    ]+  , [ \x -> case x of+              () -> 5+    ]+  , ...+  ]++map length (tiers :: [[ ()->Nat ]])  =  [1,1,1,1,1,1,...]++length (list :: [ ()->Nat ])  =  Infinity++allUnique (list :: [ ()->Nat ])  =  True++ratioRepetitions (list :: [ ()->Nat ])  =  0 % 1

+ tests/diff/tiers-funlistable-U-U.out view

@@ -0,0 +1,13 @@+tiers :: [()->()]  =+  [ [ \x -> case x of+              () -> ()+    ]+  ]++map length (tiers :: [[ ()->() ]])  =  [1]++length (list :: [ ()->() ])  =  1++allUnique (list :: [ ()->() ])  =  True++ratioRepetitions (list :: [ ()->() ])  =  0 % 1

+ tests/diff/tiers-funlistable-Us-Us.out view

@@ -0,0 +1,55 @@+tiers :: [[()]->[()]]  =+  [ [ \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [()]+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    ]+  , [ \x -> case x of+              [] -> [(),()]+              [()] -> [(),()]+              [(),()] -> [(),()]+              [(),(),()] -> [(),()]+              [(),(),(),()] -> [(),()]+              [(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),(),()] -> [(),()]+              ...+    ]+  , [ \x -> case x of+              [] -> [(),(),()]+              [()] -> [(),(),()]+              [(),()] -> [(),(),()]+              [(),(),()] -> [(),(),()]+              [(),(),(),()] -> [(),(),()]+              [(),(),(),(),()] -> [(),(),()]+              [(),(),(),(),(),()] -> [(),(),()]+              [(),(),(),(),(),(),()] -> [(),(),()]+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [()]->[()] ]])  =  [1,1,1,1,...]++length (list :: [ [()]->[()] ])  =  Infinity++allUnique (list :: [ [()]->[()] ])  =  True++ratioRepetitions (list :: [ [()]->[()] ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Bool-Bool.out view

@@ -0,0 +1,23 @@+tiers :: [Bool->Bool]  =+  [ [ \x -> case x of+              False -> False+              True -> False+    , \x -> case x of+              False -> False+              True -> True+    , \x -> case x of+              False -> True+              True -> False+    , \x -> case x of+              False -> True+              True -> True+    ]+  ]++map length (tiers :: [[ Bool->Bool ]])  =  [4]++length (list :: [ Bool->Bool ])  =  4++allUnique (list :: [ Bool->Bool ])  =  True++ratioRepetitions (list :: [ Bool->Bool ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Bool-MBool.out view

@@ -0,0 +1,40 @@+tiers :: [Bool->Maybe Bool]  =+  [ [ \x -> case x of+              False -> Nothing+              True -> Nothing+    ]+  , [ \x -> case x of+              False -> Nothing+              True -> Just False+    , \x -> case x of+              False -> Nothing+              True -> Just True+    , \x -> case x of+              False -> Just False+              True -> Nothing+    , \x -> case x of+              False -> Just True+              True -> Nothing+    ]+  , [ \x -> case x of+              False -> Just False+              True -> Just False+    , \x -> case x of+              False -> Just False+              True -> Just True+    , \x -> case x of+              False -> Just True+              True -> Just False+    , \x -> case x of+              False -> Just True+              True -> Just True+    ]+  ]++map length (tiers :: [[ Bool->Maybe Bool ]])  =  [1,4,4]++length (list :: [ Bool->Maybe Bool ])  =  9++allUnique (list :: [ Bool->Maybe Bool ])  =  True++ratioRepetitions (list :: [ Bool->Maybe Bool ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Bool-U.out view

@@ -0,0 +1,14 @@+tiers :: [Bool->()]  =+  [ [ \x -> case x of+              False -> ()+              True -> ()+    ]+  ]++map length (tiers :: [[ Bool->() ]])  =  [1]++length (list :: [ Bool->() ])  =  1++allUnique (list :: [ Bool->() ])  =  True++ratioRepetitions (list :: [ Bool->() ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Bools-Bools.out view

@@ -0,0 +1,385 @@+tiers :: [[Bool]->[Bool]]  =+  [ [ \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [False]+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    ]+  , [ \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [False,False]+              [False] -> [False,False]+              [True] -> [False,False]+              [False,False] -> [False,False]+              [False,True] -> [False,False]+              [True,False] -> [False,False]+              [True,True] -> [False,False]+              [False,False,False] -> [False,False]+              ...+    , \x -> case x of+              [] -> [False,True]+              [False] -> [False,True]+              [True] -> [False,True]+              [False,False] -> [False,True]+              [False,True] -> [False,True]+              [True,False] -> [False,True]+              [True,True] -> [False,True]+              [False,False,False] -> [False,True]+              ...+    , \x -> case x of+              [] -> [True,False]+              [False] -> [True,False]+              [True] -> [True,False]+              [False,False] -> [True,False]+              [False,True] -> [True,False]+              [True,False] -> [True,False]+              [True,True] -> [True,False]+              [False,False,False] -> [True,False]+              ...+    , \x -> case x of+              [] -> [True,True]+              [False] -> [True,True]+              [True] -> [True,True]+              [False,False] -> [True,True]+              [False,True] -> [True,True]+              [True,False] -> [True,True]+              [True,True] -> [True,True]+              [False,False,False] -> [True,True]+              ...+    ]+  , [ \x -> case x of+              [] -> [False,False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False,True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True,False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True,True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> [False]+              [True] -> []+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [True]+              [True] -> []+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False,False]+              [True] -> [False,False]+              [False,False] -> [False,False]+              [False,True] -> [False,False]+              [True,False] -> [False,False]+              [True,True] -> [False,False]+              [False,False,False] -> [False,False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False,True]+              [True] -> [False,True]+              [False,False] -> [False,True]+              [False,True] -> [False,True]+              [True,False] -> [False,True]+              [True,True] -> [False,True]+              [False,False,False] -> [False,True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True,False]+              [True] -> [True,False]+              [False,False] -> [True,False]+              [False,True] -> [True,False]+              [True,False] -> [True,False]+              [True,True] -> [True,False]+              [False,False,False] -> [True,False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True,True]+              [True] -> [True,True]+              [False,False] -> [True,True]+              [False,True] -> [True,True]+              [True,False] -> [True,True]+              [True,True] -> [True,True]+              [False,False,False] -> [True,True]+              ...+    , \x -> case x of+              [] -> [False,False,False]+              [False] -> [False,False,False]+              [True] -> [False,False,False]+              [False,False] -> [False,False,False]+              [False,True] -> [False,False,False]+              [True,False] -> [False,False,False]+              [True,True] -> [False,False,False]+              [False,False,False] -> [False,False,False]+              ...+    , \x -> case x of+              [] -> [False,False,True]+              [False] -> [False,False,True]+              [True] -> [False,False,True]+              [False,False] -> [False,False,True]+              [False,True] -> [False,False,True]+              [True,False] -> [False,False,True]+              [True,True] -> [False,False,True]+              [False,False,False] -> [False,False,True]+              ...+    , \x -> case x of+              [] -> [False,True,False]+              [False] -> [False,True,False]+              [True] -> [False,True,False]+              [False,False] -> [False,True,False]+              [False,True] -> [False,True,False]+              [True,False] -> [False,True,False]+              [True,True] -> [False,True,False]+              [False,False,False] -> [False,True,False]+              ...+    , \x -> case x of+              [] -> [False,True,True]+              [False] -> [False,True,True]+              [True] -> [False,True,True]+              [False,False] -> [False,True,True]+              [False,True] -> [False,True,True]+              [True,False] -> [False,True,True]+              [True,True] -> [False,True,True]+              [False,False,False] -> [False,True,True]+              ...+    , \x -> case x of+              [] -> [True,False,False]+              [False] -> [True,False,False]+              [True] -> [True,False,False]+              [False,False] -> [True,False,False]+              [False,True] -> [True,False,False]+              [True,False] -> [True,False,False]+              [True,True] -> [True,False,False]+              [False,False,False] -> [True,False,False]+              ...+    , \x -> case x of+              [] -> [True,False,True]+              [False] -> [True,False,True]+              [True] -> [True,False,True]+              [False,False] -> [True,False,True]+              [False,True] -> [True,False,True]+              [True,False] -> [True,False,True]+              [True,True] -> [True,False,True]+              [False,False,False] -> [True,False,True]+              ...+    , \x -> case x of+              [] -> [True,True,False]+              [False] -> [True,True,False]+              [True] -> [True,True,False]+              [False,False] -> [True,True,False]+              [False,True] -> [True,True,False]+              [True,False] -> [True,True,False]+              [True,True] -> [True,True,False]+              [False,False,False] -> [True,True,False]+              ...+    , \x -> case x of+              [] -> [True,True,True]+              [False] -> [True,True,True]+              [True] -> [True,True,True]+              [False,False] -> [True,True,True]+              [False,True] -> [True,True,True]+              [True,False] -> [True,True,True]+              [True,True] -> [True,True,True]+              [False,False,False] -> [True,True,True]+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Bool]->[Bool] ]])  =  [1,2,8,26,...]++length (list :: [ [Bool]->[Bool] ])  =  Infinity++allUnique (list :: [ [Bool]->[Bool] ])  =  True++ratioRepetitions (list :: [ [Bool]->[Bool] ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Int-Int-Int.out view

@@ -0,0 +1,215 @@+tiers :: [Int->Int->Int]  =+  [ [ \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> -1+                (1,-1) -> -1+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> 0+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> -1+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,-1) -> 2+                (1,1) -> 2+                (-1,0) -> 2+                (0,2) -> 2+                (1,-1) -> 2+                ...+    ]+  , ...+  ]++map length (tiers :: [[ Int->Int->Int ]])  =  [1,1,5,13,...]++length (list :: [ Int->Int->Int ])  =  Infinity++allUnique (list :: [ Int->Int->Int ])  =  True++ratioRepetitions (list :: [ Int->Int->Int ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Int-Int.out view

@@ -0,0 +1,377 @@+tiers :: [Int->Int]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    ]+  , [ \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              -1 -> 2+              2 -> 2+              -2 -> 2+              3 -> 2+              -3 -> 2+              4 -> 2+              ...+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> -1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              -1 -> 2+              2 -> 2+              -2 -> 2+              3 -> 2+              -3 -> 2+              4 -> 2+              ...+    , \x -> case x of+              0 -> -2+              1 -> -2+              -1 -> -2+              2 -> -2+              -2 -> -2+              3 -> -2+              -3 -> -2+              4 -> -2+              ...+    ]+  , [ \x -> case x of+              0 -> -2+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> -1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> -1+              1 -> 1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              -1 -> 2+              2 -> 2+              -2 -> 2+              3 -> 2+              -3 -> 2+              4 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              -1 -> 2+              2 -> 2+              -2 -> 2+              3 -> 2+              -3 -> 2+              4 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> -2+              -1 -> -2+              2 -> -2+              -2 -> -2+              3 -> -2+              -3 -> -2+              4 -> -2+              ...+    , \x -> case x of+              0 -> 3+              1 -> 3+              -1 -> 3+              2 -> 3+              -2 -> 3+              3 -> 3+              -3 -> 3+              4 -> 3+              ...+    ]+  , ...+  ]++map length (tiers :: [[ Int->Int ]])  =  [1,1,3,5,10,16,...]++length (list :: [ Int->Int ])  =  Infinity++allUnique (list :: [ Int->Int ])  =  True++ratioRepetitions (list :: [ Int->Int ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Ints-Ints.out view

@@ -0,0 +1,175 @@+tiers :: [[Int]->[Int]]  =+  [ [ \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> [0,0]+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [-1] -> [0,0]+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [-1] -> [1]+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [-1] -> [0,0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [-1] -> [1]+              ...+    , \x -> case x of+              [] -> [0,0,0]+              [0] -> [0,0,0]+              [0,0] -> [0,0,0]+              [1] -> [0,0,0]+              [0,0,0] -> [0,0,0]+              [0,1] -> [0,0,0]+              [1,0] -> [0,0,0]+              [-1] -> [0,0,0]+              ...+    , \x -> case x of+              [] -> [0,1]+              [0] -> [0,1]+              [0,0] -> [0,1]+              [1] -> [0,1]+              [0,0,0] -> [0,1]+              [0,1] -> [0,1]+              [1,0] -> [0,1]+              [-1] -> [0,1]+              ...+    , \x -> case x of+              [] -> [1,0]+              [0] -> [1,0]+              [0,0] -> [1,0]+              [1] -> [1,0]+              [0,0,0] -> [1,0]+              [0,1] -> [1,0]+              [1,0] -> [1,0]+              [-1] -> [1,0]+              ...+    , \x -> case x of+              [] -> [-1]+              [0] -> [-1]+              [0,0] -> [-1]+              [1] -> [-1]+              [0,0,0] -> [-1]+              [0,1] -> [-1]+              [1,0] -> [-1]+              [-1] -> [-1]+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Int]->[Int] ]])  =  [1,1,4,10,...]++length (list :: [ [Int]->[Int] ])  =  Infinity++allUnique (list :: [ [Int]->[Int] ])  =  True++ratioRepetitions (list :: [ [Int]->[Int] ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-MBool-Bool.out view

@@ -0,0 +1,43 @@+tiers :: [Maybe Bool->Bool]  =+  [ [ \x -> case x of+              Nothing -> False+              Just False -> False+              Just True -> False+    , \x -> case x of+              Nothing -> False+              Just False -> False+              Just True -> True+    , \x -> case x of+              Nothing -> False+              Just False -> True+              Just True -> False+    , \x -> case x of+              Nothing -> False+              Just False -> True+              Just True -> True+    , \x -> case x of+              Nothing -> True+              Just False -> False+              Just True -> False+    , \x -> case x of+              Nothing -> True+              Just False -> False+              Just True -> True+    , \x -> case x of+              Nothing -> True+              Just False -> True+              Just True -> False+    , \x -> case x of+              Nothing -> True+              Just False -> True+              Just True -> True+    ]+  ]++map length (tiers :: [[ Maybe Bool->Bool ]])  =  [8]++length (list :: [ Maybe Bool->Bool ])  =  8++allUnique (list :: [ Maybe Bool->Bool ])  =  True++ratioRepetitions (list :: [ Maybe Bool->Bool ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-MBool-MBool.out view

@@ -0,0 +1,122 @@+tiers :: [Maybe Bool->Maybe Bool]  =+  [ [ \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Nothing+    ]+  , [ \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Nothing+    ]+  , [ \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Nothing+    ]+  , [ \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Just True+    ]+  ]++map length (tiers :: [[ Maybe Bool->Maybe Bool ]])  =  [1,6,12,8]++length (list :: [ Maybe Bool->Maybe Bool ])  =  Infinity++allUnique (list :: [ Maybe Bool->Maybe Bool ])  =  True++ratioRepetitions (list :: [ Maybe Bool->Maybe Bool ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Nat,Nat-Nat.out view

@@ -0,0 +1,135 @@+tiers :: [(Nat,Nat)->Nat]  =+  [ [ \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    ]+  , [ \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    ]+  , [ \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 2+              (0,1) -> 2+              (1,0) -> 2+              (0,2) -> 2+              (1,1) -> 2+              (2,0) -> 2+              (0,3) -> 2+              (1,2) -> 2+              ...+    ]+  , [ \x -> case x of+              (0,0) -> 2+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 2+              (1,0) -> 2+              (0,2) -> 2+              (1,1) -> 2+              (2,0) -> 2+              (0,3) -> 2+              (1,2) -> 2+              ...+    , \x -> case x of+              (0,0) -> 3+              (0,1) -> 3+              (1,0) -> 3+              (0,2) -> 3+              (1,1) -> 3+              (2,0) -> 3+              (0,3) -> 3+              (1,2) -> 3+              ...+    ]+  , ...+  ]++map length (tiers :: [[ (Nat,Nat)->Nat ]])  =  [1,1,3,7,...]++length (list :: [ (Nat,Nat)->Nat ])  =  Infinity++allUnique (list :: [ (Nat,Nat)->Nat ])  =  True++ratioRepetitions (list :: [ (Nat,Nat)->Nat ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Nat-Nat-Nat.out view

@@ -0,0 +1,215 @@+tiers :: [Nat->Nat->Nat]  =+  [ [ \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,2) -> 2+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 2+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 3+                (0,1) -> 3+                (1,0) -> 3+                (0,2) -> 3+                (1,1) -> 3+                (2,0) -> 3+                (0,3) -> 3+                (1,2) -> 3+                ...+    ]+  , ...+  ]++map length (tiers :: [[ Nat->Nat->Nat ]])  =  [1,1,5,13,...]++length (list :: [ Nat->Nat->Nat ])  =  Infinity++allUnique (list :: [ Nat->Nat->Nat ])  =  True++ratioRepetitions (list :: [ Nat->Nat->Nat ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Nat-Nat.out view

@@ -0,0 +1,377 @@+tiers :: [Nat->Nat]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 3+              1 -> 3+              2 -> 3+              3 -> 3+              4 -> 3+              5 -> 3+              6 -> 3+              7 -> 3+              ...+    ]+  , [ \x -> case x of+              0 -> 3+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 3+              2 -> 3+              3 -> 3+              4 -> 3+              5 -> 3+              6 -> 3+              7 -> 3+              ...+    , \x -> case x of+              0 -> 4+              1 -> 4+              2 -> 4+              3 -> 4+              4 -> 4+              5 -> 4+              6 -> 4+              7 -> 4+              ...+    ]+  , [ \x -> case x of+              0 -> 4+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 3+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 3+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 1+              1 -> 3+              2 -> 3+              3 -> 3+              4 -> 3+              5 -> 3+              6 -> 3+              7 -> 3+              ...+    , \x -> case x of+              0 -> 3+              1 -> 0+              2 -> 3+              3 -> 3+              4 -> 3+              5 -> 3+              6 -> 3+              7 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 4+              2 -> 4+              3 -> 4+              4 -> 4+              5 -> 4+              6 -> 4+              7 -> 4+              ...+    , \x -> case x of+              0 -> 5+              1 -> 5+              2 -> 5+              3 -> 5+              4 -> 5+              5 -> 5+              6 -> 5+              7 -> 5+              ...+    ]+  , ...+  ]++map length (tiers :: [[ Nat->Nat ]])  =  [1,1,3,5,10,16,...]++length (list :: [ Nat->Nat ])  =  Infinity++allUnique (list :: [ Nat->Nat ])  =  True++ratioRepetitions (list :: [ Nat->Nat ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Nat-U.out view

@@ -0,0 +1,27 @@+tiers :: [Nat->()]  =+  [ [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , []+  , []+  , []+  , []+  , []+  , ...+  ]++map length (tiers :: [[ Nat->() ]])  =  [1,0,0,0,0,0,...]++length (list :: [ Nat->() ])  =  1++allUnique (list :: [ Nat->() ])  =  True++ratioRepetitions (list :: [ Nat->() ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Nat2-Nat2.out view

@@ -0,0 +1,25 @@+tiers :: [Nat2->Nat2]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+    ]+  ]++map length (tiers :: [[ Nat2->Nat2 ]])  =  [1,2,1]++length (list :: [ Nat2->Nat2 ])  =  4++allUnique (list :: [ Nat2->Nat2 ])  =  True++ratioRepetitions (list :: [ Nat2->Nat2 ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Nat2-Nat3.out view

@@ -0,0 +1,42 @@+tiers :: [Nat2->Nat3]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 2+    ]+  ]++map length (tiers :: [[ Nat2->Nat3 ]])  =  [1,2,3,2,1]++length (list :: [ Nat2->Nat3 ])  =  9++allUnique (list :: [ Nat2->Nat3 ])  =  True++ratioRepetitions (list :: [ Nat2->Nat3 ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Nat3-Nat2.out view

@@ -0,0 +1,46 @@+tiers :: [Nat3->Nat2]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+    ]+  ]++map length (tiers :: [[ Nat3->Nat2 ]])  =  [1,3,3,1]++length (list :: [ Nat3->Nat2 ])  =  8++allUnique (list :: [ Nat3->Nat2 ])  =  True++ratioRepetitions (list :: [ Nat3->Nat2 ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Nat3-Nat3.out view

@@ -0,0 +1,125 @@+tiers :: [Nat3->Nat3]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 0+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 1+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 2+    ]+  ]++map length (tiers :: [[ Nat3->Nat3 ]])  =  [1,3,6,7,6,3,1]++length (list :: [ Nat3->Nat3 ])  =  Infinity++allUnique (list :: [ Nat3->Nat3 ])  =  True++ratioRepetitions (list :: [ Nat3->Nat3 ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Nats-Nats.out view

@@ -0,0 +1,175 @@+tiers :: [[Nat]->[Nat]]  =+  [ [ \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> [0,0]+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [2] -> [0,0]+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [2] -> [1]+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [2] -> [0,0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [2] -> [1]+              ...+    , \x -> case x of+              [] -> [0,0,0]+              [0] -> [0,0,0]+              [0,0] -> [0,0,0]+              [1] -> [0,0,0]+              [0,0,0] -> [0,0,0]+              [0,1] -> [0,0,0]+              [1,0] -> [0,0,0]+              [2] -> [0,0,0]+              ...+    , \x -> case x of+              [] -> [0,1]+              [0] -> [0,1]+              [0,0] -> [0,1]+              [1] -> [0,1]+              [0,0,0] -> [0,1]+              [0,1] -> [0,1]+              [1,0] -> [0,1]+              [2] -> [0,1]+              ...+    , \x -> case x of+              [] -> [1,0]+              [0] -> [1,0]+              [0,0] -> [1,0]+              [1] -> [1,0]+              [0,0,0] -> [1,0]+              [0,1] -> [1,0]+              [1,0] -> [1,0]+              [2] -> [1,0]+              ...+    , \x -> case x of+              [] -> [2]+              [0] -> [2]+              [0,0] -> [2]+              [1] -> [2]+              [0,0,0] -> [2]+              [0,1] -> [2]+              [1,0] -> [2]+              [2] -> [2]+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Nat]->[Nat] ]])  =  [1,1,4,10,...]++length (list :: [ [Nat]->[Nat] ])  =  Infinity++allUnique (list :: [ [Nat]->[Nat] ])  =  True++ratioRepetitions (list :: [ [Nat]->[Nat] ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-U-Bool.out view

@@ -0,0 +1,15 @@+tiers :: [()->Bool]  =+  [ [ \x -> case x of+              () -> False+    , \x -> case x of+              () -> True+    ]+  ]++map length (tiers :: [[ ()->Bool ]])  =  [2]++length (list :: [ ()->Bool ])  =  2++allUnique (list :: [ ()->Bool ])  =  True++ratioRepetitions (list :: [ ()->Bool ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-U-Nat.out view

@@ -0,0 +1,29 @@+tiers :: [()->Nat]  =+  [ [ \x -> case x of+              () -> 0+    ]+  , [ \x -> case x of+              () -> 1+    ]+  , [ \x -> case x of+              () -> 2+    ]+  , [ \x -> case x of+              () -> 3+    ]+  , [ \x -> case x of+              () -> 4+    ]+  , [ \x -> case x of+              () -> 5+    ]+  , ...+  ]++map length (tiers :: [[ ()->Nat ]])  =  [1,1,1,1,1,1,...]++length (list :: [ ()->Nat ])  =  Infinity++allUnique (list :: [ ()->Nat ])  =  True++ratioRepetitions (list :: [ ()->Nat ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-U-U.out view

@@ -0,0 +1,13 @@+tiers :: [()->()]  =+  [ [ \x -> case x of+              () -> ()+    ]+  ]++map length (tiers :: [[ ()->() ]])  =  [1]++length (list :: [ ()->() ])  =  1++allUnique (list :: [ ()->() ])  =  True++ratioRepetitions (list :: [ ()->() ])  =  0 % 1

+ tests/diff/tiers-listsofpairs-Us-Us.out view

@@ -0,0 +1,115 @@+tiers :: [[()]->[()]]  =+  [ [ \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [()]+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    ]+  , [ \x -> case x of+              [] -> [()]+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> []+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> [(),()]+              [()] -> [(),()]+              [(),()] -> [(),()]+              [(),(),()] -> [(),()]+              [(),(),(),()] -> [(),()]+              [(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),(),()] -> [(),()]+              ...+    ]+  , [ \x -> case x of+              [] -> [(),()]+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> []+              [()] -> [()]+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> [()]+              [()] -> []+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> [(),()]+              [(),()] -> [(),()]+              [(),(),()] -> [(),()]+              [(),(),(),()] -> [(),()]+              [(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),(),()] -> [(),()]+              ...+    , \x -> case x of+              [] -> [(),(),()]+              [()] -> [(),(),()]+              [(),()] -> [(),(),()]+              [(),(),()] -> [(),(),()]+              [(),(),(),()] -> [(),(),()]+              [(),(),(),(),()] -> [(),(),()]+              [(),(),(),(),(),()] -> [(),(),()]+              [(),(),(),(),(),(),()] -> [(),(),()]+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [()]->[()] ]])  =  [1,1,3,5,...]++length (list :: [ [()]->[()] ])  =  Infinity++allUnique (list :: [ [()]->[()] ])  =  True++ratioRepetitions (list :: [ [()]->[()] ])  =  0 % 1

+ tests/diff/tiers-mixed-Bool-Bool.out view

@@ -0,0 +1,35 @@+tiers :: [Bool->Bool]  =+  [ [ \x -> case x of+              False -> False+              True -> False+    , \x -> case x of+              False -> False+              True -> True+    , \x -> case x of+              False -> True+              True -> False+    , \x -> case x of+              False -> True+              True -> True+    , \x -> case x of+              False -> False+              True -> False+    , \x -> case x of+              False -> True+              True -> False+    , \x -> case x of+              False -> False+              True -> True+    , \x -> case x of+              False -> True+              True -> True+    ]+  ]++map length (tiers :: [[ Bool->Bool ]])  =  [8]++length (list :: [ Bool->Bool ])  =  8++allUnique (list :: [ Bool->Bool ])  =  False++ratioRepetitions (list :: [ Bool->Bool ])  =  1 % 2

+ tests/diff/tiers-mixed-Bool-MBool.out view

@@ -0,0 +1,67 @@+tiers :: [Bool->Maybe Bool]  =+  [ [ \x -> case x of+              False -> Nothing+              True -> Nothing+    , \x -> case x of+              False -> Nothing+              True -> Nothing+    ]+  , [ \x -> case x of+              False -> Nothing+              True -> Just False+    , \x -> case x of+              False -> Nothing+              True -> Just True+    , \x -> case x of+              False -> Just False+              True -> Nothing+    , \x -> case x of+              False -> Just True+              True -> Nothing+    , \x -> case x of+              False -> Just False+              True -> Nothing+    , \x -> case x of+              False -> Just True+              True -> Nothing+    , \x -> case x of+              False -> Nothing+              True -> Just False+    , \x -> case x of+              False -> Nothing+              True -> Just True+    ]+  , [ \x -> case x of+              False -> Just False+              True -> Just False+    , \x -> case x of+              False -> Just False+              True -> Just True+    , \x -> case x of+              False -> Just True+              True -> Just False+    , \x -> case x of+              False -> Just True+              True -> Just True+    , \x -> case x of+              False -> Just False+              True -> Just False+    , \x -> case x of+              False -> Just True+              True -> Just False+    , \x -> case x of+              False -> Just False+              True -> Just True+    , \x -> case x of+              False -> Just True+              True -> Just True+    ]+  ]++map length (tiers :: [[ Bool->Maybe Bool ]])  =  [2,8,8]++length (list :: [ Bool->Maybe Bool ])  =  Infinity++allUnique (list :: [ Bool->Maybe Bool ])  =  False++ratioRepetitions (list :: [ Bool->Maybe Bool ])  =  1 % 2

+ tests/diff/tiers-mixed-Bool-U.out view

@@ -0,0 +1,17 @@+tiers :: [Bool->()]  =+  [ [ \x -> case x of+              False -> ()+              True -> ()+    , \x -> case x of+              False -> ()+              True -> ()+    ]+  ]++map length (tiers :: [[ Bool->() ]])  =  [2]++length (list :: [ Bool->() ])  =  2++allUnique (list :: [ Bool->() ])  =  False++ratioRepetitions (list :: [ Bool->() ])  =  1 % 2

+ tests/diff/tiers-mixed-Bools-Bools.out view

@@ -0,0 +1,1115 @@+tiers :: [[Bool]->[Bool]]  =+  [ [ \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [False]+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [False,False]+              [False] -> [False,False]+              [True] -> [False,False]+              [False,False] -> [False,False]+              [False,True] -> [False,False]+              [True,False] -> [False,False]+              [True,True] -> [False,False]+              [False,False,False] -> [False,False]+              ...+    , \x -> case x of+              [] -> [False,True]+              [False] -> [False,True]+              [True] -> [False,True]+              [False,False] -> [False,True]+              [False,True] -> [False,True]+              [True,False] -> [False,True]+              [True,True] -> [False,True]+              [False,False,False] -> [False,True]+              ...+    , \x -> case x of+              [] -> [True,False]+              [False] -> [True,False]+              [True] -> [True,False]+              [False,False] -> [True,False]+              [False,True] -> [True,False]+              [True,False] -> [True,False]+              [True,True] -> [True,False]+              [False,False,False] -> [True,False]+              ...+    , \x -> case x of+              [] -> [True,True]+              [False] -> [True,True]+              [True] -> [True,True]+              [False,False] -> [True,True]+              [False,True] -> [True,True]+              [True,False] -> [True,True]+              [True,True] -> [True,True]+              [False,False,False] -> [True,True]+              ...+    , \x -> case x of+              [] -> [False,False]+              [False] -> [False,False]+              [True] -> [False,False]+              [False,False] -> [False,False]+              [False,True] -> [False,False]+              [True,False] -> [False,False]+              [True,True] -> [False,False]+              [False,False,False] -> [False,False]+              ...+    , \x -> case x of+              [] -> [False,True]+              [False] -> [False,True]+              [True] -> [False,True]+              [False,False] -> [False,True]+              [False,True] -> [False,True]+              [True,False] -> [False,True]+              [True,True] -> [False,True]+              [False,False,False] -> [False,True]+              ...+    , \x -> case x of+              [] -> [True,False]+              [False] -> [True,False]+              [True] -> [True,False]+              [False,False] -> [True,False]+              [False,True] -> [True,False]+              [True,False] -> [True,False]+              [True,True] -> [True,False]+              [False,False,False] -> [True,False]+              ...+    , \x -> case x of+              [] -> [True,True]+              [False] -> [True,True]+              [True] -> [True,True]+              [False,False] -> [True,True]+              [False,True] -> [True,True]+              [True,False] -> [True,True]+              [True,True] -> [True,True]+              [False,False,False] -> [True,True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> []+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> []+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [False,False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False,True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True,False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True,True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> [False]+              [True] -> []+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [True]+              [True] -> []+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False,False]+              [True] -> [False,False]+              [False,False] -> [False,False]+              [False,True] -> [False,False]+              [True,False] -> [False,False]+              [True,True] -> [False,False]+              [False,False,False] -> [False,False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False,True]+              [True] -> [False,True]+              [False,False] -> [False,True]+              [False,True] -> [False,True]+              [True,False] -> [False,True]+              [True,True] -> [False,True]+              [False,False,False] -> [False,True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True,False]+              [True] -> [True,False]+              [False,False] -> [True,False]+              [False,True] -> [True,False]+              [True,False] -> [True,False]+              [True,True] -> [True,False]+              [False,False,False] -> [True,False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True,True]+              [True] -> [True,True]+              [False,False] -> [True,True]+              [False,True] -> [True,True]+              [True,False] -> [True,True]+              [True,True] -> [True,True]+              [False,False,False] -> [True,True]+              ...+    , \x -> case x of+              [] -> [False,False,False]+              [False] -> [False,False,False]+              [True] -> [False,False,False]+              [False,False] -> [False,False,False]+              [False,True] -> [False,False,False]+              [True,False] -> [False,False,False]+              [True,True] -> [False,False,False]+              [False,False,False] -> [False,False,False]+              ...+    , \x -> case x of+              [] -> [False,False,True]+              [False] -> [False,False,True]+              [True] -> [False,False,True]+              [False,False] -> [False,False,True]+              [False,True] -> [False,False,True]+              [True,False] -> [False,False,True]+              [True,True] -> [False,False,True]+              [False,False,False] -> [False,False,True]+              ...+    , \x -> case x of+              [] -> [False,True,False]+              [False] -> [False,True,False]+              [True] -> [False,True,False]+              [False,False] -> [False,True,False]+              [False,True] -> [False,True,False]+              [True,False] -> [False,True,False]+              [True,True] -> [False,True,False]+              [False,False,False] -> [False,True,False]+              ...+    , \x -> case x of+              [] -> [False,True,True]+              [False] -> [False,True,True]+              [True] -> [False,True,True]+              [False,False] -> [False,True,True]+              [False,True] -> [False,True,True]+              [True,False] -> [False,True,True]+              [True,True] -> [False,True,True]+              [False,False,False] -> [False,True,True]+              ...+    , \x -> case x of+              [] -> [True,False,False]+              [False] -> [True,False,False]+              [True] -> [True,False,False]+              [False,False] -> [True,False,False]+              [False,True] -> [True,False,False]+              [True,False] -> [True,False,False]+              [True,True] -> [True,False,False]+              [False,False,False] -> [True,False,False]+              ...+    , \x -> case x of+              [] -> [True,False,True]+              [False] -> [True,False,True]+              [True] -> [True,False,True]+              [False,False] -> [True,False,True]+              [False,True] -> [True,False,True]+              [True,False] -> [True,False,True]+              [True,True] -> [True,False,True]+              [False,False,False] -> [True,False,True]+              ...+    , \x -> case x of+              [] -> [True,True,False]+              [False] -> [True,True,False]+              [True] -> [True,True,False]+              [False,False] -> [True,True,False]+              [False,True] -> [True,True,False]+              [True,False] -> [True,True,False]+              [True,True] -> [True,True,False]+              [False,False,False] -> [True,True,False]+              ...+    , \x -> case x of+              [] -> [True,True,True]+              [False] -> [True,True,True]+              [True] -> [True,True,True]+              [False,False] -> [True,True,True]+              [False,True] -> [True,True,True]+              [True,False] -> [True,True,True]+              [True,True] -> [True,True,True]+              [False,False,False] -> [True,True,True]+              ...+    , \x -> case x of+              [] -> [False,False,False]+              [False] -> [False,False,False]+              [True] -> [False,False,False]+              [False,False] -> [False,False,False]+              [False,True] -> [False,False,False]+              [True,False] -> [False,False,False]+              [True,True] -> [False,False,False]+              [False,False,False] -> [False,False,False]+              ...+    , \x -> case x of+              [] -> [False,False,True]+              [False] -> [False,False,True]+              [True] -> [False,False,True]+              [False,False] -> [False,False,True]+              [False,True] -> [False,False,True]+              [True,False] -> [False,False,True]+              [True,True] -> [False,False,True]+              [False,False,False] -> [False,False,True]+              ...+    , \x -> case x of+              [] -> [False,True,False]+              [False] -> [False,True,False]+              [True] -> [False,True,False]+              [False,False] -> [False,True,False]+              [False,True] -> [False,True,False]+              [True,False] -> [False,True,False]+              [True,True] -> [False,True,False]+              [False,False,False] -> [False,True,False]+              ...+    , \x -> case x of+              [] -> [False,True,True]+              [False] -> [False,True,True]+              [True] -> [False,True,True]+              [False,False] -> [False,True,True]+              [False,True] -> [False,True,True]+              [True,False] -> [False,True,True]+              [True,True] -> [False,True,True]+              [False,False,False] -> [False,True,True]+              ...+    , \x -> case x of+              [] -> [True,False,False]+              [False] -> [True,False,False]+              [True] -> [True,False,False]+              [False,False] -> [True,False,False]+              [False,True] -> [True,False,False]+              [True,False] -> [True,False,False]+              [True,True] -> [True,False,False]+              [False,False,False] -> [True,False,False]+              ...+    , \x -> case x of+              [] -> [True,False,True]+              [False] -> [True,False,True]+              [True] -> [True,False,True]+              [False,False] -> [True,False,True]+              [False,True] -> [True,False,True]+              [True,False] -> [True,False,True]+              [True,True] -> [True,False,True]+              [False,False,False] -> [True,False,True]+              ...+    , \x -> case x of+              [] -> [True,True,False]+              [False] -> [True,True,False]+              [True] -> [True,True,False]+              [False,False] -> [True,True,False]+              [False,True] -> [True,True,False]+              [True,False] -> [True,True,False]+              [True,True] -> [True,True,False]+              [False,False,False] -> [True,True,False]+              ...+    , \x -> case x of+              [] -> [True,True,True]+              [False] -> [True,True,True]+              [True] -> [True,True,True]+              [False,False] -> [True,True,True]+              [False,True] -> [True,True,True]+              [True,False] -> [True,True,True]+              [True,True] -> [True,True,True]+              [False,False,False] -> [True,True,True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False,False]+              [True] -> []+              [False,False] -> [False,False]+              [False,True] -> [False,False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False,False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False,True]+              [True] -> []+              [False,False] -> [False,True]+              [False,True] -> [False,True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False,True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True,False]+              [True] -> []+              [False,False] -> [True,False]+              [False,True] -> [True,False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True,False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True,True]+              [True] -> []+              [False,False] -> [True,True]+              [False,True] -> [True,True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True,True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> [False]+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> [True]+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> [False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> [True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> [False]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> [False]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> [True]+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> [True]+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> [False]+              [True] -> []+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> []+              [False] -> [True]+              [True] -> []+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False,False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False,False]+              [True,True] -> [False,False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False,True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False,True]+              [True,True] -> [False,True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True,False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True,False]+              [True,True] -> [True,False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True,True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True,True]+              [True,True] -> [True,True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False]+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True]+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> [False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> [True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> []+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> [False]+              [True] -> []+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> [True]+              [True] -> []+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [False]+              [True] -> []+              [False,False] -> [False]+              [False,True] -> [False]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [False]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> [True]+              [True] -> []+              [False,False] -> [True]+              [False,True] -> [True]+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> [True]+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> [False]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [False]+              [True,True] -> [False]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> [True]+              [False,False] -> []+              [False,True] -> []+              [True,False] -> [True]+              [True,True] -> [True]+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False,False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [False,True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True,False]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    , \x -> case x of+              [] -> [True,True]+              [False] -> []+              [True] -> []+              [False,False] -> []+              [False,True] -> []+              [True,False] -> []+              [True,True] -> []+              [False,False,False] -> []+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Bool]->[Bool] ]])  =  [2,5,20,83,...]++length (list :: [ [Bool]->[Bool] ])  =  Infinity++allUnique (list :: [ [Bool]->[Bool] ])  =  False++ratioRepetitions (list :: [ [Bool]->[Bool] ])  =  43 % 110

+ tests/diff/tiers-mixed-Int-Int-Int.out view

@@ -0,0 +1,3625 @@+tiers :: [Int->Int->Int]  =+  [ [ \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> 0+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> -1+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,-1) -> 2+                (1,1) -> 2+                (-1,0) -> 2+                (0,2) -> 2+                (1,-1) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,-1) -> 2+                (1,1) -> 2+                (-1,0) -> 2+                (0,2) -> 2+                (1,-1) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> -1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> 0+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> -1+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,-1) -> 2+                (1,1) -> 2+                (-1,0) -> 2+                (0,2) -> 2+                (1,-1) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,-1) -> 2+                (1,1) -> 2+                (-1,0) -> 2+                (0,2) -> 2+                (1,-1) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> -1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> 0+                (1,1) -> -1+                (-1,0) -> -1+                (0,2) -> -1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> -1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 1+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 1+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> -1+                (0,1) -> -1+                (1,0) -> -1+                (0,-1) -> -1+                (1,1) -> -1+                (-1,0) -> 0+                (0,2) -> -1+                (1,-1) -> -1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,-1) -> 1+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 1+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,-1) -> 0+                (1,1) -> 1+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,-1) -> 0+                (1,1) -> 0+                (-1,0) -> 0+                (0,2) -> 0+                (1,-1) -> 0+                ...+    ]+  , ...+  ]++map length (tiers :: [[ Int->Int->Int ]])  =  [4,12,58,287,...]++length (list :: [ Int->Int->Int ])  =  Infinity++allUnique (list :: [ Int->Int->Int ])  =  False++ratioRepetitions (list :: [ Int->Int->Int ])  =  315 % 361

+ tests/diff/tiers-mixed-Int-Int.out view

@@ -0,0 +1,2997 @@+tiers :: [Int->Int]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              -1 -> 2+              2 -> 2+              -2 -> 2+              3 -> 2+              -3 -> 2+              4 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              -1 -> 2+              2 -> 2+              -2 -> 2+              3 -> 2+              -3 -> 2+              4 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> -1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              -1 -> 2+              2 -> 2+              -2 -> 2+              3 -> 2+              -3 -> 2+              4 -> 2+              ...+    , \x -> case x of+              0 -> -2+              1 -> -2+              -1 -> -2+              2 -> -2+              -2 -> -2+              3 -> -2+              -3 -> -2+              4 -> -2+              ...+    , \x -> case x of+              0 -> -2+              1 -> -2+              -1 -> -2+              2 -> -2+              -2 -> -2+              3 -> -2+              -3 -> -2+              4 -> -2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 2+              2 -> 0+              -2 -> 2+              3 -> 0+              -3 -> 2+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> -1+              2 -> 1+              -2 -> -1+              3 -> 1+              -3 -> -1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 1+              2 -> -1+              -2 -> 1+              3 -> -1+              -3 -> 1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              -1 -> 0+              2 -> 2+              -2 -> 0+              3 -> 2+              -3 -> 0+              4 -> 2+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> -2+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> -1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> -1+              1 -> 1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              -1 -> 2+              2 -> 2+              -2 -> 2+              3 -> 2+              -3 -> 2+              4 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              -1 -> 2+              2 -> 2+              -2 -> 2+              3 -> 2+              -3 -> 2+              4 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> -2+              -1 -> -2+              2 -> -2+              -2 -> -2+              3 -> -2+              -3 -> -2+              4 -> -2+              ...+    , \x -> case x of+              0 -> 3+              1 -> 3+              -1 -> 3+              2 -> 3+              -2 -> 3+              3 -> 3+              -3 -> 3+              4 -> 3+              ...+    , \x -> case x of+              0 -> 3+              1 -> 3+              -1 -> 3+              2 -> 3+              -2 -> 3+              3 -> 3+              -3 -> 3+              4 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -2+              2 -> 0+              -2 -> -2+              3 -> 0+              -3 -> -2+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 2+              3 -> 0+              -3 -> 2+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 2+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 2+              2 -> 1+              -2 -> 2+              3 -> 1+              -3 -> 2+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> -1+              3 -> 1+              -3 -> -1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> -1+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 2+              2 -> 0+              -2 -> 2+              3 -> 0+              -3 -> 2+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> -1+              2 -> -1+              -2 -> -1+              3 -> -1+              -3 -> -1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 1+              3 -> -1+              -3 -> 1+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 1+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> -1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> -1+              2 -> 1+              -2 -> -1+              3 -> 1+              -3 -> -1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> -1+              2 -> 0+              -2 -> -1+              3 -> 0+              -3 -> -1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              -1 -> 1+              2 -> 2+              -2 -> 1+              3 -> 2+              -3 -> 1+              4 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              -1 -> 0+              2 -> 2+              -2 -> 0+              3 -> 2+              -3 -> 0+              4 -> 2+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 1+              2 -> -1+              -2 -> 1+              3 -> -1+              -3 -> 1+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 1+              -2 -> 1+              3 -> 1+              -3 -> 1+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 1+              2 -> 0+              -2 -> 1+              3 -> 0+              -3 -> 1+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -2+              1 -> -2+              -1 -> 0+              2 -> -2+              -2 -> 0+              3 -> -2+              -3 -> 0+              4 -> -2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> -1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> -1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              -1 -> 0+              2 -> 2+              -2 -> 0+              3 -> 2+              -3 -> 0+              4 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> -1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> -1+              -2 -> 0+              3 -> -1+              -3 -> 0+              4 -> -1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 1+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 1+              -3 -> 0+              4 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              -1 -> 0+              2 -> 0+              -2 -> 0+              3 -> 0+              -3 -> 0+              4 -> 0+              ...+    ]+  , ...+  ]++map length (tiers :: [[ Int->Int ]])  =  [2,3,8,20,61,204,...]++length (list :: [ Int->Int ])  =  Infinity++allUnique (list :: [ Int->Int ])  =  False++ratioRepetitions (list :: [ Int->Int ])  =  211 % 298

+ tests/diff/tiers-mixed-Ints-Ints.out view

@@ -0,0 +1,475 @@+tiers :: [[Int]->[Int]]  =+  [ [ \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> [0,0]+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [-1] -> [0,0]+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [-1] -> [1]+              ...+    , \x -> case x of+              [] -> [0,0]+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [-1] -> [0,0]+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [-1] -> [1]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [-1] -> [0,0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [-1] -> [1]+              ...+    , \x -> case x of+              [] -> [0,0,0]+              [0] -> [0,0,0]+              [0,0] -> [0,0,0]+              [1] -> [0,0,0]+              [0,0,0] -> [0,0,0]+              [0,1] -> [0,0,0]+              [1,0] -> [0,0,0]+              [-1] -> [0,0,0]+              ...+    , \x -> case x of+              [] -> [0,1]+              [0] -> [0,1]+              [0,0] -> [0,1]+              [1] -> [0,1]+              [0,0,0] -> [0,1]+              [0,1] -> [0,1]+              [1,0] -> [0,1]+              [-1] -> [0,1]+              ...+    , \x -> case x of+              [] -> [1,0]+              [0] -> [1,0]+              [0,0] -> [1,0]+              [1] -> [1,0]+              [0,0,0] -> [1,0]+              [0,1] -> [1,0]+              [1,0] -> [1,0]+              [-1] -> [1,0]+              ...+    , \x -> case x of+              [] -> [-1]+              [0] -> [-1]+              [0,0] -> [-1]+              [1] -> [-1]+              [0,0,0] -> [-1]+              [0,1] -> [-1]+              [1,0] -> [-1]+              [-1] -> [-1]+              ...+    , \x -> case x of+              [] -> [0,0,0]+              [0] -> [0,0,0]+              [0,0] -> [0,0,0]+              [1] -> [0,0,0]+              [0,0,0] -> [0,0,0]+              [0,1] -> [0,0,0]+              [1,0] -> [0,0,0]+              [-1] -> [0,0,0]+              ...+    , \x -> case x of+              [] -> [0,1]+              [0] -> [0,1]+              [0,0] -> [0,1]+              [1] -> [0,1]+              [0,0,0] -> [0,1]+              [0,1] -> [0,1]+              [1,0] -> [0,1]+              [-1] -> [0,1]+              ...+    , \x -> case x of+              [] -> [1,0]+              [0] -> [1,0]+              [0,0] -> [1,0]+              [1] -> [1,0]+              [0,0,0] -> [1,0]+              [0,1] -> [1,0]+              [1,0] -> [1,0]+              [-1] -> [1,0]+              ...+    , \x -> case x of+              [] -> [-1]+              [0] -> [-1]+              [0,0] -> [-1]+              [1] -> [-1]+              [0,0,0] -> [-1]+              [0,1] -> [-1]+              [1,0] -> [-1]+              [-1] -> [-1]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [-1] -> [0,0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [-1] -> [1]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> [0]+              [1] -> []+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> []+              [1] -> [0]+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [-1] -> [0]+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [0,0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [-1] -> []+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Int]->[Int] ]])  =  [2,3,10,31,...]++length (list :: [ [Int]->[Int] ])  =  Infinity++allUnique (list :: [ [Int]->[Int] ])  =  False++ratioRepetitions (list :: [ [Int]->[Int] ])  =  13 % 23

+ tests/diff/tiers-mixed-MBool-Bool.out view

@@ -0,0 +1,75 @@+tiers :: [Maybe Bool->Bool]  =+  [ [ \x -> case x of+              Nothing -> False+              Just False -> False+              Just True -> False+    , \x -> case x of+              Nothing -> False+              Just False -> False+              Just True -> True+    , \x -> case x of+              Nothing -> False+              Just False -> True+              Just True -> False+    , \x -> case x of+              Nothing -> False+              Just False -> True+              Just True -> True+    , \x -> case x of+              Nothing -> True+              Just False -> False+              Just True -> False+    , \x -> case x of+              Nothing -> True+              Just False -> False+              Just True -> True+    , \x -> case x of+              Nothing -> True+              Just False -> True+              Just True -> False+    , \x -> case x of+              Nothing -> True+              Just False -> True+              Just True -> True+    , \x -> case x of+              Nothing -> False+              Just False -> False+              Just True -> False+    , \x -> case x of+              Nothing -> False+              Just False -> True+              Just True -> False+    , \x -> case x of+              Nothing -> False+              Just False -> False+              Just True -> True+    , \x -> case x of+              Nothing -> False+              Just False -> True+              Just True -> True+    , \x -> case x of+              Nothing -> True+              Just False -> False+              Just True -> False+    , \x -> case x of+              Nothing -> True+              Just False -> True+              Just True -> False+    , \x -> case x of+              Nothing -> True+              Just False -> False+              Just True -> True+    , \x -> case x of+              Nothing -> True+              Just False -> True+              Just True -> True+    ]+  ]++map length (tiers :: [[ Maybe Bool->Bool ]])  =  [16]++length (list :: [ Maybe Bool->Bool ])  =  Infinity++allUnique (list :: [ Maybe Bool->Bool ])  =  False++ratioRepetitions (list :: [ Maybe Bool->Bool ])  =  1 % 2

+ tests/diff/tiers-mixed-MBool-MBool.out view

@@ -0,0 +1,230 @@+tiers :: [Maybe Bool->Maybe Bool]  =+  [ [ \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Nothing+    ]+  , [ \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Nothing+    ]+  , [ \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Nothing+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Nothing+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Nothing+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Nothing+              Just True -> Just True+    ]+  , [ \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just False+              Just False -> Just True+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Just False+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just False+              Just True -> Just True+    , \x -> case x of+              Nothing -> Just True+              Just False -> Just True+              Just True -> Just True+    ]+  ]++map length (tiers :: [[ Maybe Bool->Maybe Bool ]])  =  [2,12,24,16]++length (list :: [ Maybe Bool->Maybe Bool ])  =  Infinity++allUnique (list :: [ Maybe Bool->Maybe Bool ])  =  False++ratioRepetitions (list :: [ Maybe Bool->Maybe Bool ])  =  1 % 2

+ tests/diff/tiers-mixed-Nat,Nat-Nat.out view

@@ -0,0 +1,745 @@+tiers :: [(Nat,Nat)->Nat]  =+  [ [ \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    ]+  , [ \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    ]+  , [ \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 2+              (0,1) -> 2+              (1,0) -> 2+              (0,2) -> 2+              (1,1) -> 2+              (2,0) -> 2+              (0,3) -> 2+              (1,2) -> 2+              ...+    , \x -> case x of+              (0,0) -> 2+              (0,1) -> 2+              (1,0) -> 2+              (0,2) -> 2+              (1,1) -> 2+              (2,0) -> 2+              (0,3) -> 2+              (1,2) -> 2+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    ]+  , [ \x -> case x of+              (0,0) -> 2+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 2+              (1,0) -> 2+              (0,2) -> 2+              (1,1) -> 2+              (2,0) -> 2+              (0,3) -> 2+              (1,2) -> 2+              ...+    , \x -> case x of+              (0,0) -> 3+              (0,1) -> 3+              (1,0) -> 3+              (0,2) -> 3+              (1,1) -> 3+              (2,0) -> 3+              (0,3) -> 3+              (1,2) -> 3+              ...+    , \x -> case x of+              (0,0) -> 3+              (0,1) -> 3+              (1,0) -> 3+              (0,2) -> 3+              (1,1) -> 3+              (2,0) -> 3+              (0,3) -> 3+              (1,2) -> 3+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 2+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 2+              (2,0) -> 0+              (0,3) -> 2+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 2+              (0,1) -> 0+              (1,0) -> 2+              (0,2) -> 2+              (1,1) -> 0+              (2,0) -> 2+              (0,3) -> 0+              (1,2) -> 2+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 2+              (0,2) -> 0+              (1,1) -> 2+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 2+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 1+              (0,2) -> 1+              (1,1) -> 1+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 1+              (0,2) -> 0+              (1,1) -> 1+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 1+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 2+              (0,1) -> 2+              (1,0) -> 0+              (0,2) -> 2+              (1,1) -> 0+              (2,0) -> 2+              (0,3) -> 2+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 1+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 1+              (0,1) -> 1+              (1,0) -> 0+              (0,2) -> 1+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 1+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    , \x -> case x of+              (0,0) -> 0+              (0,1) -> 0+              (1,0) -> 0+              (0,2) -> 0+              (1,1) -> 0+              (2,0) -> 0+              (0,3) -> 0+              (1,2) -> 0+              ...+    ]+  , ...+  ]++map length (tiers :: [[ (Nat,Nat)->Nat ]])  =  [2,4,14,53,...]++length (list :: [ (Nat,Nat)->Nat ])  =  Infinity++allUnique (list :: [ (Nat,Nat)->Nat ])  =  False++ratioRepetitions (list :: [ (Nat,Nat)->Nat ])  =  41 % 73

+ tests/diff/tiers-mixed-Nat-Nat-Nat.out view

@@ -0,0 +1,3625 @@+tiers :: [Nat->Nat->Nat]  =+  [ [ \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,2) -> 2+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,2) -> 2+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,2) -> 2+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 2+                (0,2) -> 2+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    ]+  , [ \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 3+                (0,1) -> 3+                (1,0) -> 3+                (0,2) -> 3+                (1,1) -> 3+                (2,0) -> 3+                (0,3) -> 3+                (1,2) -> 3+                ...+    , \x y -> case (x,y) of+                (0,0) -> 3+                (0,1) -> 3+                (1,0) -> 3+                (0,2) -> 3+                (1,1) -> 3+                (2,0) -> 3+                (0,3) -> 3+                (1,2) -> 3+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 3+                (0,1) -> 3+                (1,0) -> 3+                (0,2) -> 3+                (1,1) -> 3+                (2,0) -> 3+                (0,3) -> 3+                (1,2) -> 3+                ...+    , \x y -> case (x,y) of+                (0,0) -> 3+                (0,1) -> 3+                (1,0) -> 3+                (0,2) -> 3+                (1,1) -> 3+                (2,0) -> 3+                (0,3) -> 3+                (1,2) -> 3+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 2+                (0,2) -> 0+                (1,1) -> 2+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 2+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 1+                (0,2) -> 1+                (1,1) -> 1+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 1+                (0,2) -> 0+                (1,1) -> 1+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 1+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 2+                (0,1) -> 2+                (1,0) -> 0+                (0,2) -> 2+                (1,1) -> 0+                (2,0) -> 2+                (0,3) -> 2+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 1+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 1+                (0,1) -> 1+                (1,0) -> 0+                (0,2) -> 1+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 1+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    , \x y -> case (x,y) of+                (0,0) -> 0+                (0,1) -> 0+                (1,0) -> 0+                (0,2) -> 0+                (1,1) -> 0+                (2,0) -> 0+                (0,3) -> 0+                (1,2) -> 0+                ...+    ]+  , ...+  ]++map length (tiers :: [[ Nat->Nat->Nat ]])  =  [4,12,58,287,...]++length (list :: [ Nat->Nat->Nat ])  =  Infinity++allUnique (list :: [ Nat->Nat->Nat ])  =  False++ratioRepetitions (list :: [ Nat->Nat->Nat ])  =  313 % 361

+ tests/diff/tiers-mixed-Nat-Nat.out view

@@ -0,0 +1,2997 @@+tiers :: [Nat->Nat]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 3+              1 -> 3+              2 -> 3+              3 -> 3+              4 -> 3+              5 -> 3+              6 -> 3+              7 -> 3+              ...+    , \x -> case x of+              0 -> 3+              1 -> 3+              2 -> 3+              3 -> 3+              4 -> 3+              5 -> 3+              6 -> 3+              7 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 3+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 3+              2 -> 3+              3 -> 3+              4 -> 3+              5 -> 3+              6 -> 3+              7 -> 3+              ...+    , \x -> case x of+              0 -> 4+              1 -> 4+              2 -> 4+              3 -> 4+              4 -> 4+              5 -> 4+              6 -> 4+              7 -> 4+              ...+    , \x -> case x of+              0 -> 4+              1 -> 4+              2 -> 4+              3 -> 4+              4 -> 4+              5 -> 4+              6 -> 4+              7 -> 4+              ...+    , \x -> case x of+              0 -> 0+              1 -> 3+              2 -> 0+              3 -> 3+              4 -> 0+              5 -> 3+              6 -> 0+              7 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 1+              3 -> 2+              4 -> 1+              5 -> 2+              6 -> 1+              7 -> 2+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 2+              3 -> 1+              4 -> 2+              5 -> 1+              6 -> 2+              7 -> 1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 3+              1 -> 0+              2 -> 3+              3 -> 0+              4 -> 3+              5 -> 0+              6 -> 3+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , [ \x -> case x of+              0 -> 4+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 3+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 3+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 1+              1 -> 3+              2 -> 3+              3 -> 3+              4 -> 3+              5 -> 3+              6 -> 3+              7 -> 3+              ...+    , \x -> case x of+              0 -> 3+              1 -> 0+              2 -> 3+              3 -> 3+              4 -> 3+              5 -> 3+              6 -> 3+              7 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 4+              2 -> 4+              3 -> 4+              4 -> 4+              5 -> 4+              6 -> 4+              7 -> 4+              ...+    , \x -> case x of+              0 -> 5+              1 -> 5+              2 -> 5+              3 -> 5+              4 -> 5+              5 -> 5+              6 -> 5+              7 -> 5+              ...+    , \x -> case x of+              0 -> 5+              1 -> 5+              2 -> 5+              3 -> 5+              4 -> 5+              5 -> 5+              6 -> 5+              7 -> 5+              ...+    , \x -> case x of+              0 -> 0+              1 -> 4+              2 -> 0+              3 -> 4+              4 -> 0+              5 -> 4+              6 -> 0+              7 -> 4+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 3+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 3+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 3+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 3+              2 -> 1+              3 -> 3+              4 -> 1+              5 -> 3+              6 -> 1+              7 -> 3+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 2+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 2+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 2+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 3+              2 -> 0+              3 -> 3+              4 -> 0+              5 -> 3+              6 -> 0+              7 -> 3+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 2+              3 -> 2+              4 -> 2+              5 -> 2+              6 -> 2+              7 -> 2+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 1+              4 -> 2+              5 -> 0+              6 -> 2+              7 -> 1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 2+              3 -> 0+              4 -> 2+              5 -> 1+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 1+              3 -> 2+              4 -> 0+              5 -> 2+              6 -> 1+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 1+              5 -> 2+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+              3 -> 2+              4 -> 0+              5 -> 2+              6 -> 0+              7 -> 2+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 3+              1 -> 1+              2 -> 3+              3 -> 1+              4 -> 3+              5 -> 1+              6 -> 3+              7 -> 1+              ...+    , \x -> case x of+              0 -> 3+              1 -> 0+              2 -> 3+              3 -> 0+              4 -> 3+              5 -> 0+              6 -> 3+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 2+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 2+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 1+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 2+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 1+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+              3 -> 1+              4 -> 0+              5 -> 1+              6 -> 0+              7 -> 1+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 4+              1 -> 0+              2 -> 4+              3 -> 0+              4 -> 4+              5 -> 0+              6 -> 4+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 3+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 3+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 2+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 1+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 3+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 3+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 2+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 1+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+              3 -> 0+              4 -> 0+              5 -> 0+              6 -> 0+              7 -> 0+              ...+    ]+  , ...+  ]++map length (tiers :: [[ Nat->Nat ]])  =  [2,3,8,20,61,204,...]++length (list :: [ Nat->Nat ])  =  Infinity++allUnique (list :: [ Nat->Nat ])  =  False++ratioRepetitions (list :: [ Nat->Nat ])  =  85 % 149

+ tests/diff/tiers-mixed-Nat-U.out view

@@ -0,0 +1,677 @@+tiers :: [Nat->()]  =+  [ [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , [ \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    , \x -> case x of+              0 -> ()+              1 -> ()+              2 -> ()+              3 -> ()+              4 -> ()+              5 -> ()+              6 -> ()+              7 -> ()+              ...+    ]+  , ...+  ]++map length (tiers :: [[ Nat->() ]])  =  [2,1,2,5,14,42,...]++length (list :: [ Nat->() ])  =  Infinity++allUnique (list :: [ Nat->() ])  =  False++ratioRepetitions (list :: [ Nat->() ])  =  65 % 66

+ tests/diff/tiers-mixed-Nat2-Nat2.out view

@@ -0,0 +1,37 @@+tiers :: [Nat2->Nat2]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 1+    ]+  ]++map length (tiers :: [[ Nat2->Nat2 ]])  =  [2,4,2]++length (list :: [ Nat2->Nat2 ])  =  8++allUnique (list :: [ Nat2->Nat2 ])  =  False++ratioRepetitions (list :: [ Nat2->Nat2 ])  =  1 % 2

+ tests/diff/tiers-mixed-Nat2-Nat3.out view

@@ -0,0 +1,69 @@+tiers :: [Nat2->Nat3]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 2+    ]+  ]++map length (tiers :: [[ Nat2->Nat3 ]])  =  [2,4,6,4,2]++length (list :: [ Nat2->Nat3 ])  =  Infinity++allUnique (list :: [ Nat2->Nat3 ])  =  False++ratioRepetitions (list :: [ Nat2->Nat3 ])  =  1 % 2

+ tests/diff/tiers-mixed-Nat3-Nat2.out view

@@ -0,0 +1,78 @@+tiers :: [Nat3->Nat2]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+    ]+  ]++map length (tiers :: [[ Nat3->Nat2 ]])  =  [2,6,6,2]++length (list :: [ Nat3->Nat2 ])  =  Infinity++allUnique (list :: [ Nat3->Nat2 ])  =  False++ratioRepetitions (list :: [ Nat3->Nat2 ])  =  1 % 2

+ tests/diff/tiers-mixed-Nat3-Nat3.out view

@@ -0,0 +1,233 @@+tiers :: [Nat3->Nat3]  =+  [ [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 0+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 0+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 0+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 0+    , \x -> case x of+              0 -> 0+              1 -> 2+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 0+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 1+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 0+    ]+  , [ \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 1+    , \x -> case x of+              0 -> 1+              1 -> 2+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 1+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 1+    ]+  , [ \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 2+    , \x -> case x of+              0 -> 2+              1 -> 2+              2 -> 2+    ]+  ]++map length (tiers :: [[ Nat3->Nat3 ]])  =  [2,6,12,14,12,6,2]++length (list :: [ Nat3->Nat3 ])  =  Infinity++allUnique (list :: [ Nat3->Nat3 ])  =  False++ratioRepetitions (list :: [ Nat3->Nat3 ])  =  1 % 2

+ tests/diff/tiers-mixed-Nats-Nats.out view

@@ -0,0 +1,475 @@+tiers :: [[Nat]->[Nat]]  =+  [ [ \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> [0,0]+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [2] -> [0,0]+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [2] -> [1]+              ...+    , \x -> case x of+              [] -> [0,0]+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [2] -> [0,0]+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [2] -> [1]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [0,0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [2] -> [0,0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [2] -> [1]+              ...+    , \x -> case x of+              [] -> [0,0,0]+              [0] -> [0,0,0]+              [0,0] -> [0,0,0]+              [1] -> [0,0,0]+              [0,0,0] -> [0,0,0]+              [0,1] -> [0,0,0]+              [1,0] -> [0,0,0]+              [2] -> [0,0,0]+              ...+    , \x -> case x of+              [] -> [0,1]+              [0] -> [0,1]+              [0,0] -> [0,1]+              [1] -> [0,1]+              [0,0,0] -> [0,1]+              [0,1] -> [0,1]+              [1,0] -> [0,1]+              [2] -> [0,1]+              ...+    , \x -> case x of+              [] -> [1,0]+              [0] -> [1,0]+              [0,0] -> [1,0]+              [1] -> [1,0]+              [0,0,0] -> [1,0]+              [0,1] -> [1,0]+              [1,0] -> [1,0]+              [2] -> [1,0]+              ...+    , \x -> case x of+              [] -> [2]+              [0] -> [2]+              [0,0] -> [2]+              [1] -> [2]+              [0,0,0] -> [2]+              [0,1] -> [2]+              [1,0] -> [2]+              [2] -> [2]+              ...+    , \x -> case x of+              [] -> [0,0,0]+              [0] -> [0,0,0]+              [0,0] -> [0,0,0]+              [1] -> [0,0,0]+              [0,0,0] -> [0,0,0]+              [0,1] -> [0,0,0]+              [1,0] -> [0,0,0]+              [2] -> [0,0,0]+              ...+    , \x -> case x of+              [] -> [0,1]+              [0] -> [0,1]+              [0,0] -> [0,1]+              [1] -> [0,1]+              [0,0,0] -> [0,1]+              [0,1] -> [0,1]+              [1,0] -> [0,1]+              [2] -> [0,1]+              ...+    , \x -> case x of+              [] -> [1,0]+              [0] -> [1,0]+              [0,0] -> [1,0]+              [1] -> [1,0]+              [0,0,0] -> [1,0]+              [0,1] -> [1,0]+              [1,0] -> [1,0]+              [2] -> [1,0]+              ...+    , \x -> case x of+              [] -> [2]+              [0] -> [2]+              [0,0] -> [2]+              [1] -> [2]+              [0,0,0] -> [2]+              [0,1] -> [2]+              [1,0] -> [2]+              [2] -> [2]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0,0]+              [0,0] -> [0,0]+              [1] -> [0,0]+              [0,0,0] -> [0,0]+              [0,1] -> [0,0]+              [1,0] -> [0,0]+              [2] -> [0,0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> [1]+              [0,0] -> [1]+              [1] -> [1]+              [0,0,0] -> [1]+              [0,1] -> [1]+              [1,0] -> [1]+              [2] -> [1]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> [0]+              [1] -> []+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> []+              [1] -> [0]+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> [0]+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> [0]+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> [0]+              [0,0] -> [0]+              [1] -> []+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> []+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> []+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> [0]+              [0,0] -> [0]+              [1] -> [0]+              [0,0,0] -> [0]+              [0,1] -> [0]+              [1,0] -> [0]+              [2] -> [0]+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [0,0]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    , \x -> case x of+              [] -> [1]+              [0] -> []+              [0,0] -> []+              [1] -> []+              [0,0,0] -> []+              [0,1] -> []+              [1,0] -> []+              [2] -> []+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [Nat]->[Nat] ]])  =  [2,3,10,31,...]++length (list :: [ [Nat]->[Nat] ])  =  Infinity++allUnique (list :: [ [Nat]->[Nat] ])  =  False++ratioRepetitions (list :: [ [Nat]->[Nat] ])  =  13 % 23

+ tests/diff/tiers-mixed-U-Bool.out view

@@ -0,0 +1,19 @@+tiers :: [()->Bool]  =+  [ [ \x -> case x of+              () -> False+    , \x -> case x of+              () -> True+    , \x -> case x of+              () -> False+    , \x -> case x of+              () -> True+    ]+  ]++map length (tiers :: [[ ()->Bool ]])  =  [4]++length (list :: [ ()->Bool ])  =  4++allUnique (list :: [ ()->Bool ])  =  False++ratioRepetitions (list :: [ ()->Bool ])  =  1 % 2

+ tests/diff/tiers-mixed-U-Nat.out view

@@ -0,0 +1,41 @@+tiers :: [()->Nat]  =+  [ [ \x -> case x of+              () -> 0+    , \x -> case x of+              () -> 0+    ]+  , [ \x -> case x of+              () -> 1+    , \x -> case x of+              () -> 1+    ]+  , [ \x -> case x of+              () -> 2+    , \x -> case x of+              () -> 2+    ]+  , [ \x -> case x of+              () -> 3+    , \x -> case x of+              () -> 3+    ]+  , [ \x -> case x of+              () -> 4+    , \x -> case x of+              () -> 4+    ]+  , [ \x -> case x of+              () -> 5+    , \x -> case x of+              () -> 5+    ]+  , ...+  ]++map length (tiers :: [[ ()->Nat ]])  =  [2,2,2,2,2,2,...]++length (list :: [ ()->Nat ])  =  Infinity++allUnique (list :: [ ()->Nat ])  =  False++ratioRepetitions (list :: [ ()->Nat ])  =  1 % 2

+ tests/diff/tiers-mixed-U-U.out view

@@ -0,0 +1,15 @@+tiers :: [()->()]  =+  [ [ \x -> case x of+              () -> ()+    , \x -> case x of+              () -> ()+    ]+  ]++map length (tiers :: [[ ()->() ]])  =  [2]++length (list :: [ ()->() ])  =  2++allUnique (list :: [ ()->() ])  =  False++ratioRepetitions (list :: [ ()->() ])  =  1 % 2

+ tests/diff/tiers-mixed-Us-Us.out view

@@ -0,0 +1,265 @@+tiers :: [[()]->[()]]  =+  [ [ \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [()]+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> [()]+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [()]+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> []+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> [(),()]+              [()] -> [(),()]+              [(),()] -> [(),()]+              [(),(),()] -> [(),()]+              [(),(),(),()] -> [(),()]+              [(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),(),()] -> [(),()]+              ...+    , \x -> case x of+              [] -> [(),()]+              [()] -> [(),()]+              [(),()] -> [(),()]+              [(),(),()] -> [(),()]+              [(),(),(),()] -> [(),()]+              [(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),(),()] -> [(),()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> [()]+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    ]+  , [ \x -> case x of+              [] -> [(),()]+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> []+              [()] -> [()]+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> [()]+              [()] -> []+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> [(),()]+              [(),()] -> [(),()]+              [(),(),()] -> [(),()]+              [(),(),(),()] -> [(),()]+              [(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),(),()] -> [(),()]+              ...+    , \x -> case x of+              [] -> [(),(),()]+              [()] -> [(),(),()]+              [(),()] -> [(),(),()]+              [(),(),()] -> [(),(),()]+              [(),(),(),()] -> [(),(),()]+              [(),(),(),(),()] -> [(),(),()]+              [(),(),(),(),(),()] -> [(),(),()]+              [(),(),(),(),(),(),()] -> [(),(),()]+              ...+    , \x -> case x of+              [] -> [(),(),()]+              [()] -> [(),(),()]+              [(),()] -> [(),(),()]+              [(),(),()] -> [(),(),()]+              [(),(),(),()] -> [(),(),()]+              [(),(),(),(),()] -> [(),(),()]+              [(),(),(),(),(),()] -> [(),(),()]+              [(),(),(),(),(),(),()] -> [(),(),()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> [(),()]+              [(),()] -> [(),()]+              [(),(),()] -> [(),()]+              [(),(),(),()] -> [(),()]+              [(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),()] -> [(),()]+              [(),(),(),(),(),(),()] -> [(),()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> []+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> []+              [()] -> [()]+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> [()]+              [()] -> [()]+              [(),()] -> [()]+              [(),(),()] -> [()]+              [(),(),(),()] -> [()]+              [(),(),(),(),()] -> [()]+              [(),(),(),(),(),()] -> [()]+              [(),(),(),(),(),(),()] -> [()]+              ...+    , \x -> case x of+              [] -> [()]+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    , \x -> case x of+              [] -> [(),()]+              [()] -> []+              [(),()] -> []+              [(),(),()] -> []+              [(),(),(),()] -> []+              [(),(),(),(),()] -> []+              [(),(),(),(),(),()] -> []+              [(),(),(),(),(),(),()] -> []+              ...+    ]+  , ...+  ]++map length (tiers :: [[ [()]->[()] ]])  =  [2,3,7,13,...]++length (list :: [ [()]->[()] ])  =  Infinity++allUnique (list :: [ [()]->[()] ])  =  False++ratioRepetitions (list :: [ [()]->[()] ])  =  14 % 25

+ tests/diff/tiers.out view

@@ -0,0 +1,10 @@+tiers :: [()]  =+  [[()]]++map length (tiers :: [[ () ]])  =  [1]++length (list :: [ () ])  =  1++allUnique (list :: [ () ])  =  True++ratioRepetitions (list :: [ () ])  =  0 % 1

tests/test-derive.hs view

@@ -5,7 +5,7 @@ import Test.LeanCheck import Test.LeanCheck.Derive import System.Exit (exitFailure)-import Data.List (elemIndices)+import Data.List (elemIndices,sort) import Test.LeanCheck.Utils.Operators  data D0       = D0                    deriving Show@@ -85,6 +85,19 @@   , map unD1 list == (list :: [Bool])   , map unD2 list == (list :: [(Bool,Bool)])   , map unD3 list == (list :: [(Bool,Bool,Bool)])++  , (tiers :: [[ Bool       ]]) =| 6 |= $(deriveTiers ''Bool)+  , (tiers :: [[ [Int]      ]]) =| 6 |= $(deriveTiers ''[])+  , (tiers :: [[ [Bool]     ]]) =| 6 |= $(deriveTiers ''[])+  , (tiers :: [[ Maybe Int  ]]) =| 6 |= $(deriveTiers ''Maybe)+  , (tiers :: [[ Maybe Bool ]]) =| 6 |= $(deriveTiers ''Maybe)+  , ([]:tiers :: [[Either Bool Int]]) =$ map sort . take 6 $= $(deriveTiers ''Either)++  , (list :: [ Bool       ]) =| n |= $(deriveList ''Bool)+  , (list :: [ [Int]      ]) =| n |= $(deriveList ''[])+  , (list :: [ [Bool]     ]) =| n |= $(deriveList ''[])+  , (list :: [ Maybe Int  ]) =| n |= $(deriveList ''Maybe)+  , (list :: [ Maybe Bool ]) =| n |= $(deriveList ''Maybe)   ]   where   unD0 (D0)       = ()

+ tests/test-fun.hs view

@@ -0,0 +1,29 @@+-- Copyright (c) 2015-2017 Rudy Matela.+-- Distributed under the 3-Clause BSD licence (see the file LICENSE).+import Test++import System.Exit (exitFailure)+import Data.List (elemIndices, sort, nub, delete)++import Test.LeanCheck+import Test.LeanCheck.Function.ListsOfPairs+import Test.LeanCheck.Utils+++main :: IO ()+main =+  case elemIndices False tests of+    [] -> putStrLn "Tests passed!"+    is -> do putStrLn ("Failed tests:" ++ show is)+             exitFailure++tests =+  [ True+  -- TODO: add some tests here+  ]++allUnique :: Ord a => [a] -> Bool+allUnique [] = True+allUnique (x:xs) = x `notElem` xs+                && allUnique (filter (< x) xs)+                && allUnique (filter (> x) xs)

+ tests/test-funshow.hs view

@@ -0,0 +1,80 @@+-- Copyright (c) 2015-2017 Rudy Matela.+-- Distributed under the 3-Clause BSD licence (see the file LICENSE).+import Test++import System.Exit (exitFailure)+import Data.List (elemIndices,sort)+import Test.LeanCheck.Function.ShowFunction+import Test.LeanCheck.Function.Show+import Test.LeanCheck.Utils.TypeBinding++main :: IO ()+main =+  case elemIndices False tests of+    [] -> putStrLn "Tests passed!"+    is -> do putStrLn ("Failed tests:" ++ show is)+             exitFailure+++tests =+  [ True++  -- undefined values --+  , showFunction 2 int == "undefined"+  , showFunction 2 bool == "undefined"+  , showFunction 2 char == "undefined"+  , showFunctionLine 10 (int  >- int) == "\\x -> case x of ..."+  , showFunctionLine 10 (bool >- bool) == "\\x -> undefined"++  -- partially defined --+  , showFunctionLine 2 (\x -> case x of True -> True)+                   == "\\x -> case x of True -> True"+  , showFunctionLine 10 (\x -> case (x::Int) of 3 -> (4::Int); 5 -> 6)+                    == "\\x -> case x of 3 -> 4; 5 -> 6; ..."+  , showFunctionLine 10 (\x y -> case (x::Int,y::Int) of (1,2) -> (3::Int); (2,1) -> 3)+                    == "\\x y -> case (x,y) of (1,2) -> 3; (2,1) -> 3; ..."++  -- fully defined, infinite --+  , showFunction 3 ((+) -:> int)+    == "\\x y -> case (x,y) of\n"+    ++ "          (0,0) -> 0\n"+    ++ "          (0,1) -> 1\n"+    ++ "          (1,0) -> 1\n"+    ++ "          ...\n"+  , showFunction 3 ((++) -:> [int])+    == "\\x y -> case (x,y) of\n"+    ++ "          ([],[]) -> []\n"+    ++ "          ([],[0]) -> [0]\n"+    ++ "          ([0],[]) -> [0]\n"+    ++ "          ...\n"+  , showFunction 4 (sort -:> [char])+    == "\\x -> case x of\n"+    ++ "        \"\" -> \"\"\n"+    ++ "        \"a\" -> \"a\"\n"+    ++ "        \"aa\" -> \"aa\"\n"+    ++ "        \" \" -> \" \"\n"+    ++ "        ...\n"+++  -- fully defined, finite --+  , showFunction 1 not+    == "\\x -> case x of\n"+    ++ "        False -> True\n"+    ++ "        ...\n"+  , showFunction 2 not+    == "\\x -> case x of\n"+    ++ "        False -> True\n"+    ++ "        True -> False\n"+  , showFunction 3 (&&)+    == "\\x y -> case (x,y) of\n"+    ++ "          (False,False) -> False\n"+    ++ "          (False,True) -> False\n"+    ++ "          (True,False) -> False\n"+    ++ "          ...\n"+  , showFunction 4 (&&)+    == "\\x y -> case (x,y) of\n"+    ++ "          (False,False) -> False\n"+    ++ "          (False,True) -> False\n"+    ++ "          (True,False) -> False\n"+    ++ "          (True,True) -> True\n"+  ]

+ tests/test-io.hs view

@@ -0,0 +1,10 @@+-- Copyright (c) 2015-2017 Rudy Matela.+-- Distributed under the 3-Clause BSD licence (see the file LICENSE).+import Test+import Test.LeanCheck.IO++main :: IO ()+main = do+  check $ \x -> (x::Int) + x == 2*x    -- should pass+--check $ \x -> (x::Int) + x == x      -- should fail, falsifiable+--check $ \x -> (x::Int) `div` x == 1  -- should fail, exception

+ tests/test-sdist view

@@ -0,0 +1,31 @@+#!/bin/bash+#+# test-sdist: tests the package generated by "cabal sdist".+#+# Copyright (c) 2015-2017 Rudy Matela.+# Distributed under the 3-Clause BSD licence.+#+# TODO: also run "make test"+# TODO: also run "stack test"+pkgver=` cat *.cabal | grep "^version:" | sed -e "s/version: *//"`+pkgname=`cat *.cabal | grep "^name:"    | sed -e "s/name: *//"`+pkg=$pkgname-$pkgver+set -x+cabal sdist &&+cd dist &&+rm -rf $pkg/ &&+tar -xzf $pkg.tar.gz &&+cd $pkg/ &&+cabal configure --enable-tests --enable-benchmarks &&+cabal build &&+cabal test &&+cd .. &&+if [ -d ../.git ]+then+	git -C .. ls-files                                      | sort > ls-git   &&+	tar -tf $pkg.tar.gz | grep -v "/$" | sed -e "s,$pkg/,," | sort > ls-cabal &&+	diff -rud ls-git ls-cabal &&+	rm -f ls-git ls-cabal+else+	true # skip test+fi

+ tests/test-stats.hs view

@@ -0,0 +1,45 @@+-- Copyright (c) 2017 Rudy Matela.+-- Distributed under the 3-Clause BSD licence (see the file LICENSE).+import Test++import System.Exit (exitFailure)+import Data.List (elemIndices,sort)+import Test.LeanCheck+import Test.LeanCheck.Stats++import Data.List (isPrefixOf)+import Data.Function (on)++main :: IO ()+main = do+  putStrLn "sum :: [Int] -> Bool"+  classStats 100 (sum     :: [Int] -> Int)++  putStrLn "length :: [Int] -> Int"+  classStats 100 (length  :: [Int] -> Int)++  putStrLn "take 1 :: [Int] -> [Int]"+  classStats 100 (take 1  :: [Int] -> [Int])++  conditionStats 1000 [ ("odd",odd :: Int -> Bool)+                      , ("even",even) ]++  conditionStats 1000 [ ("ordered",ordered :: [Int] -> Bool)+                      , ("ordered . reverse", ordered . reverse) ]++  case elemIndices False (tests 100) of+    [] -> putStrLn "Tests passed!"+    is -> do putStrLn ("Failed tests:" ++ show is)+             exitFailure++tests :: Int -> [Bool]+tests n =+  [ True++  , classify                   [1,2,3,4,1,2,3,1,2,1] == [[1,1,1,1],[2,2,2],[3,3],[4]]+  , classifyBy ((==) `on` odd) [1,2,3,4,1,2,3,1,2,1] == [[1,3,1,3,1,1],[2,4,2,2]]+  , classifyOn odd             [1,2,3,4,1,2,3,1,2,1] == [[1,3,1,3,1,1],[2,4,2,2]]+  , counts                   [1,2,3,4,1,2,3,1,2,1] == [(1,4),(2,3),(3,2),(4,1)]+  , countsBy ((==) `on` odd) [1,2,3,4,1,2,3,1,2,1] == [(1,6),(2,4)]+  , countsOn odd             [1,2,3,4,1,2,3,1,2,1::Int] == [(True,6),(False,4)]+  ]