diff --git a/.travis.yml b/.travis.yml --- a/.travis.yml +++ b/.travis.yml @@ -1,6 +1,6 @@ # .travis.yml file for Speculate # -# Copyright: (c) 2017-2020 Rudy Matela +# Copyright: (c) 2017-2021 Rudy Matela # License: 3-Clause BSD (see the file LICENSE) # Maintainer: Rudy Matela @@ -34,7 +34,7 @@ - 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 -- cabal install leancheck express cmdargs || cabal install leancheck express cmdargs --lib +- cabal install leancheck express cmdargs || cabal v1-install leancheck express cmdargs script: - make && make test @@ -45,17 +45,21 @@ matrix: allow_failures: - - ghc: 'head' + - env: GHCVER=head CABALVER=head STACKVER=nightly-2021-04-06 + - env: GHCVER=9.0.1 CABALVER=head STACKVER=nightly-2021-04-06 include: - ghc: 'head' - env: GHCVER=head CABALVER=head STACKVER=nightly-2020-03-28 - addons: {apt: {packages: [ghc-head, cabal-install-head], sources: hvr-ghc}} + env: GHCVER=head CABALVER=head STACKVER=nightly-2021-04-06 + addons: {apt: {packages: [ghc-head, cabal-install-head], sources: hvr-ghc}} + - ghc: '9.0' + env: GHCVER=9.0.1 CABALVER=head STACKVER=nightly-2021-04-06 + addons: {apt: {packages: [ghc-9.0.1, cabal-install-head], sources: hvr-ghc}} - ghc: '8.10' - env: GHCVER=8.10.1 CABALVER=3.2 STACKVER=nightly-2020-03-28 - addons: {apt: {packages: [ghc-8.10.1, cabal-install-3.2], sources: hvr-ghc}} + env: GHCVER=8.10.4 CABALVER=3.2 STACKVER=lts-17.9 + addons: {apt: {packages: [ghc-8.10.4, cabal-install-3.2], sources: hvr-ghc}} - ghc: '8.8' - env: GHCVER=8.8.3 CABALVER=3.0 STACKVER=lts-15.5 - addons: {apt: {packages: [ghc-8.8.3, cabal-install-3.0], sources: hvr-ghc}} + env: GHCVER=8.8.4 CABALVER=3.0 STACKVER=lts-16.31 + addons: {apt: {packages: [ghc-8.8.4, cabal-install-3.0], sources: hvr-ghc}} - ghc: '8.6' env: GHCVER=8.6.5 CABALVER=2.4 STACKVER=lts-14.27 addons: {apt: {packages: [ghc-8.6.5, cabal-install-2.4], sources: hvr-ghc}} diff --git a/Makefile b/Makefile --- a/Makefile +++ b/Makefile @@ -104,8 +104,8 @@ cabal clean && cabal-ghc-7.8 configure && cabal-ghc-7.8 test cabal clean && cabal test -prepare-test: - cabal --ignore-sandbox install regex-tdfa cmdargs leancheck algebraic-graphs pretty-compact +prepare: + cabal v1-install cmdargs leancheck express regex-tdfa algebraic-graphs pretty-compact prepare-legacy-test: \ prepare-legacy-test-8.2 \ diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ Give Speculate a bunch of Haskell functions and it will discover laws like: * equations, such as `id x == x`; - * inequalities, such as `0 <= x * x`; + * relations of order, such as `0 <= x * x`; * conditional equations, such as `x <= 0 ==> x + abs x == 0`. Speculate is similar to, and inspired by, [QuickSpec]. @@ -91,7 +91,115 @@ For more examples, see the [eg](eg) folder. +(One can use the [TypeApplications] to simplify the above examples: +`((+) @ Int)` instead of `((+) :: Int -> Int -> Int))`. +I have chosen to keep the example [Haskell 98] compliant.) + +Supported types +--------------- + +Speculate works for virtually any type. +However, +if you would like to produce equations, +comparisons and variables of any given type +this type must be respectively +an instance of the [`Eq`], [`Ord`], [`Listable`] and [`Name`] typeclasses. + +By default, +Speculate will produce equations, comparison and variables +to [a few types](https://github.com/rudymatela/speculate/blob/master/src/Test/Speculate/Expr/Instance.hs#L110-L151) +in the [Haskell 2010 Language Report]. +If you would like expand that to more types, +you need to pass reified instances to Speculate explicitly by +using [`reifyInstances`] on [`instances =`] of [`speculate`]'s [`args`] like so: + + main = speculate args + { instances = [ reifyInstances (undefined :: ) + , reifyInstances (undefined :: ) + , reifyInstances (undefined :: ) + , ... + ] + , constants = ... + , ... + } + +To use [`reifyInstances`], +your type must be an instance of +[`Eq`], [`Ord`], [`Listable`] and [`Name`]. + +* [`Eq`] is needed for equations between values of the type; + +* [`Ord`] is needed for comparisons between values of the type; + +* [`Listable`] is needed for involving variables of the type. + This is needed in order for Speculate to be able + to generate values of your type to replace any variables. + [LeanCheck] comes with [`Listable`] instances + for virtually all types in the [Haskell 2010 Language Report]. + +* [`Name`] is needed for cosmetic puposes: + if there are any variables of your type, + [`Name`] allows you to tell Speculate how to call your variables. + For example, if you have an `User` type, you can define your name instance as: + + instance Name (User) where + name u = "usr" + + This way, variables of your `User` type will be called: + `usr`, `usr1`, `usr2`, `usr3`, etc. + +It is also fine to have only one, two or three of the above instances. +In that case, instead of [`reifyInstances`] +you can use [`reifyEq`], [`reifyOrd`], [`reifyListable`] and [`reifyName`] accordingly. +If you do not provide a [`Name`] implementation, +your variables will default to being `x`, `y` and `z`. +This may cause confusion as you involve more and more types, +compare the following two identical equations: + + [x,y] `areOwnedBy` z == z `owns` x && z `owns` y + [tckt,tckt1] `areOwnedBy` user == usr `owns` tckt && user `owns tckt1` + +The second is clearer. +So, I recomment you add a [`Name`] instance. +It is simple enough. + +You also have to do this for any user defined types you are using +or even for newtypes. + +Speculate comes with a few examples illustrating the use of [`reifyInstances`]: +on the [eg](eg) folder: +[eg/algebraic-graphs.hs](eg/algebraic-graphs.hs), +[eg/binarytree0.hs](eg/binarytree0.hs), +[eg/binarytree.hs](eg/binarytree.hs), +[eg/colour.hs](eg/colour.hs), +[eg/digraphs.hs](eg/digraphs.hs), +[eg/fun.hs](eg/fun.hs), +[eg/monad.hs](eg/monad.hs), +[eg/pretty-compact.hs](eg/pretty-compact.hs), +[eg/pretty.hs](eg/pretty.hs), +[eg/regexes.hs](eg/regexes.hs), +[eg/sets.hs](eg/sets.hs), +[eg/speculate-reason.hs](eg/speculate-reason.hs), +[eg/string.hs](eg/string.hs), +[eg/tauts.hs](eg/tauts.hs), +[eg/tuples.hs](eg/tuples.hs), +[eg/zip.hs](eg/zip.hs). + +Not having the reified instances for a given type will cause the following warnings to be printed: + + Warning: no Listable instance for , variables of this type will not be considered + Warning: no Listable instance for , variables of this type will not be considered + Warning: no Eq instance for , equations of this type will not be considered + Warning: no Eq instance for , equations of this type will not be considered + Warning: no Ord instance for , inequations of this type will not be considered + Warning: no Ord instance for , inequations of this type will not be considered + +You can silence the above warnings by following the instructions above. +However, it may be the case that you don't want variables, equations or comparisons for a given type. +If that is so, you can ignore these warnings. + + Similarities and Differences to QuickSpec ----------------------------------------- @@ -101,7 +209,7 @@ * Speculate tests enumeratively using [LeanCheck], QuickSpec tests randomly using [QuickCheck]; -* Speculate is able to report inequalities directly; +* Speculate is able to report comparisons directly; * QuickSpec allows polymorphism, Speculate does not; * For most examples, Speculate runs slower than QuickSpec 2 @@ -129,14 +237,33 @@ [PhD Thesis (2017)]: https://matela.com.br/paper/rudy-phd-thesis-2017.pdf -[`speculate`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:speculate -[`args`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:args -[`constant`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:constant +[`speculate`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:speculate +[`constant`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:constant +[`args`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:args +[`Args`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#t:Args +[`instances =`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#t:Args +[`reifyInstances`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:reifyInstances +[`reifyEq`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:reifyEq +[`reifyOrd`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:reifyOrd +[`reifyEqOrd`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:reifyEqOrd +[`reifyListable`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:reifyListable +[`reifyName`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#v:reifyName + +[`Eq`]: https://hackage.haskell.org/package/base/docs/Prelude.html#t:Eq +[`Ord`]: https://hackage.haskell.org/package/base/docs/Prelude.html#t:Ord +[`Listable`]: https://hackage.haskell.org/package/leancheck/docs/Test-LeanCheck.html#t:Listable +[`Name`]: https://hackage.haskell.org/package/speculate/docs/Test-Speculate.html#t:Name + [`(+)`]: https://hackage.haskell.org/package/base/docs/Prelude.html#v:-43- [`abs`]: https://hackage.haskell.org/package/base/docs/Prelude.html#v:abs [`<=`]: https://hackage.haskell.org/package/base/docs/Prelude.html#v:-60--61- [`<`]: https://hackage.haskell.org/package/base/docs/Prelude.html#v:-60- + +[Haskell 2010 Language Report]: https://www.haskell.org/onlinereport/haskell2010/ +[Haskell 2010]: https://www.haskell.org/onlinereport/haskell2010/ +[Haskell 98]: https://www.haskell.org/onlinereport/ +[TypeApplications]: https://gitlab.haskell.org/ghc/ghc/-/wikis/type-application [speculate-logo]: https://github.com/rudymatela/speculate/raw/master/doc/speculate.svg?sanitize=true diff --git a/bench/runtime-zero b/bench/runtime-zero --- a/bench/runtime-zero +++ b/bench/runtime-zero @@ -1,35 +1,34 @@ -GHC 8.6.5 -express-0.1.1 -leancheck-0.9.1 -arith 0.260 -arith-c 0.603 -arithficial 0.966 -arith-negate-abs 1.846 -binarytree 1.753 -binarytree0 0.520 -bool 1.983 -bool-c 1.723 -colour 2.130 -digraphs 1.560 -fun 1.190 -insertsort 8.593 -insertsort0 0.996 -length 0.646 -list 2.826 -list-c 1.770 -minus 0.603 -minus-c 0.996 -monad 0.690 +GHC 8.10.4 +express-0.1.4 +leancheck-0.9.3 +arith 0.233 +arith-c 0.570 +arithficial 0.860 +arith-negate-abs 1.713 +binarytree 1.633 +binarytree0 0.483 +bool 1.963 +bool-c 1.730 +colour 1.946 +digraphs 1.460 +fun 1.103 +insertsort 7.613 +insertsort0 0.913 +length 0.460 +list 2.586 +list-c 1.596 +minus 0.506 +minus-c 0.883 +monad 0.583 nord 0.010 -oddeven 7.340 -plus-abs 3.786 -pretty 9.080 -ratio 9.300 -regexes 8.013 -sets 7.696 -speculate-reason 3.300 -string 0.950 -tauts 4.286 -tuples 1.286 +oddeven 6.673 +plus-abs 3.543 +pretty 8.953 +ratio 8.093 +sets 7.183 +speculate-reason 3.016 +string 0.856 +tauts 4.073 +tuples 1.200 unit 0.010 -zip 2.463 +zip 2.303 diff --git a/eg/tauts.hs b/eg/tauts.hs --- a/eg/tauts.hs +++ b/eg/tauts.hs @@ -4,11 +4,11 @@ import qualified Test.Speculate as S import Taut hiding (main) -deriveListable ''Prop deriveListable ''Name +deriveListable ''Prop -deriving instance Typeable Prop deriving instance Typeable Name +deriving instance Typeable Prop prop :: Prop prop = undefined diff --git a/mk/depend.mk b/mk/depend.mk --- a/mk/depend.mk +++ b/mk/depend.mk @@ -1077,8 +1077,6 @@ src/Test/Speculate/Expr/Core.hs \ src/Test/Speculate/Engine.hs \ src/Test/Speculate/CondReason.hs -src/Test/Speculate/Expr/Core: \ - mk/toplibs src/Test/Speculate/Expr/Core.o: \ src/Test/Speculate/Utils/List.hs \ src/Test/Speculate/Expr/Core.hs diff --git a/mk/ghcdeps b/mk/ghcdeps --- a/mk/ghcdeps +++ b/mk/ghcdeps @@ -2,7 +2,7 @@ # # ghcdeps: generate Haskell make dependencies for compiling with GHC. # -# Copyright (c) 2015-2020 Rudy Matela. +# Copyright (c) 2015-2021 Rudy Matela. # Distributed under the 3-Clause BSD licence. # # From a list of files provided on standard input, @@ -46,4 +46,5 @@ rm -f tmp.mk done | sort | +grep -v "^Loaded package environment from " | sed -e 's, *, \\\n ,g' diff --git a/mk/haddock-i b/mk/haddock-i --- a/mk/haddock-i +++ b/mk/haddock-i @@ -2,7 +2,7 @@ # # haddock-i: list haddock's -i parameters. # -# Copyright (c) 2015-2020 Rudy Matela. +# Copyright (c) 2015-2021 Rudy Matela. # Distributed under the 3-Clause BSD licence. # # $ haddock-i ... diff --git a/mk/haskell.mk b/mk/haskell.mk --- a/mk/haskell.mk +++ b/mk/haskell.mk @@ -1,6 +1,6 @@ # Implicit rules for compiling Haskell code. # -# Copyright (c) 2015-2020 Rudy Matela. +# Copyright (c) 2015-2021 Rudy Matela. # Distributed under the 3-Clause BSD licence. # # You can optionally configure the "Configuration variables" below in your main diff --git a/mk/install-on b/mk/install-on --- a/mk/install-on +++ b/mk/install-on @@ -2,9 +2,12 @@ # # mk/install-on: install or updates the mk folder on a Haskell project # +# Copyright (c) 2019-2021 Rudy Matela. +# Distributed under the 3-Clause BSD licence. +# # usage: ./mk/install-on path/to/project # -# This assumes a few things: +# This script assumes that: # # * tests are stored in a "test/" folder # * sources are stored in a "src/" folder diff --git a/speculate.cabal b/speculate.cabal --- a/speculate.cabal +++ b/speculate.cabal @@ -1,5 +1,5 @@ name: speculate -version: 0.4.2 +version: 0.4.4 synopsis: discovery of properties about Haskell functions description: Speculate automatically discovers laws about Haskell functions. @@ -84,7 +84,7 @@ source-repository this type: git location: https://github.com/rudymatela/speculate - tag: v0.4.2 + tag: v0.4.4 library @@ -121,7 +121,7 @@ , Test.Speculate.Utils.Tuple build-depends: base >= 4 && < 5 , leancheck >= 0.9.3 - , express >= 0.1.3 + , express >= 0.1.4 , cmdargs , containers hs-source-dirs: src diff --git a/src/Test/Speculate/Engine.hs b/src/Test/Speculate/Engine.hs --- a/src/Test/Speculate/Engine.hs +++ b/src/Test/Speculate/Engine.hs @@ -11,8 +11,6 @@ ( expansions , expansionsOfType , expansionsWith - , mostGeneral - , mostSpecific , theoryAndRepresentativesFromAtoms , representativesFromAtoms @@ -102,14 +100,6 @@ (h,c):_ -> expansions is n `concatMap` expansionsOfType h (take n (lookupNames is h)) e --- | List the most general assignment of holes in an expression -mostGeneral :: Expr -> Expr -mostGeneral = head . fastCanonicalVariations -- TODO: make this efficient - --- | List the most specific assignment of holes in an expression -mostSpecific :: Expr -> Expr -mostSpecific = last . fastCanonicalVariations -- TODO: make this efficient - rehole :: Expr -> Expr rehole (e1 :$ e2) = rehole e1 :$ rehole e2 rehole e | isVar e = "" `varAsTypeOf` e @@ -133,6 +123,9 @@ -- > } theoryFromAtoms :: Int -> (Expr -> Expr -> Ordering) -> (Expr -> Bool) -> (Expr -> Expr -> Bool) -> [[Expr]] -> Thy theoryFromAtoms sz cmp keep (===) = fst . theoryAndRepresentativesFromAtoms sz cmp keep (===) +-- TODO: eliminate two arguments: +-- * cmp can default to use order of appearance +-- * keep can default to "const True" representativesFromAtoms :: Int -> (Expr -> Expr -> Ordering) -> (Expr -> Bool) -> (Expr -> Expr -> Bool) -> [[Expr]] -> [[Expr]] representativesFromAtoms sz cmp keep (===) = snd . theoryAndRepresentativesFromAtoms sz cmp keep (===) @@ -165,20 +158,21 @@ -- considers a schema consider :: (Expr -> Expr -> Bool) -> Int -> Expr -> (Thy,[[Expr]]) -> (Thy,[[Expr]]) consider (===) sz s (thy,sss) - | not (s === s) = (thy,sssWs) -- uncomparable type - | rehole (normalizeE thy (mostGeneral s)) `elem` ss = (thy,sss) + | ns `elem` ss = (thy,sss) + | not (ns === ns) = (thy,sssWs) -- uncomparable type | otherwise = - ( append thy $ equivalencesBetween (-===-) s s ++ eqs + ( append thy $ equivalencesBetween (-===-) ns ns ++ eqs , if any (\(e1,e2) -> unrepeatedVars e1 && unrepeatedVars e2) eqs then sss else sssWs ) - where - e1 -===- e2 = normalize thy e1 == normalize thy e2 || e1 === e2 - ss = uptoT sz sss - sssWs = sss \/ wcons0 sz s - eqs = concatMap (equivalencesBetween (-===-) s) $ filter (s ===) ss - wcons0 :: Int -> a -> [[a]] - wcons0 n s = replicate (n-1) [] ++ [[s]] + where + ns = rehole $ normalizeE thy (fastMostGeneralVariation s) + e1 -===- e2 = normalize thy e1 == normalize thy e2 || e1 === e2 + ss = uptoT sz sss + sssWs = sss \/ wcons0 sz s + eqs = concatMap (equivalencesBetween (-===-) s) $ filter (s ===) ss + wcons0 :: Int -> a -> [[a]] + wcons0 n s = replicate (n-1) [] ++ [[s]] distinctFromSchemas :: Instances -> Int -> Int -> Thy -> [Expr] -> [Expr] distinctFromSchemas ti nt nv thy = map C.rep . classesFromSchemas ti nt nv thy diff --git a/src/Test/Speculate/Expr/Core.hs b/src/Test/Speculate/Expr/Core.hs --- a/src/Test/Speculate/Expr/Core.hs +++ b/src/Test/Speculate/Expr/Core.hs @@ -23,7 +23,6 @@ -- * Assigning , Binds - , fill -- * Matching , unify @@ -83,19 +82,6 @@ _ `isConstantNamed` _ = False type Binds = [(Expr,Expr)] - --- | Fill holes in an expression. --- Silently skips holes that are not of the right type. --- Silently discard remaining expressions. -fill :: Expr -> [Expr] -> Expr -fill e = fst . fill' e - where - fill' :: Expr -> [Expr] -> (Expr,[Expr]) - fill' (e1 :$ e2) es = let (e1',es') = fill' e1 es - (e2',es'') = fill' e2 es' - in (e1' :$ e2', es'') - fill' eh (e:es) | isHole eh && typ eh == typ e = (e,es) - fill' e es = (e,es) unify :: Expr -> Expr -> Maybe Expr unify e1 e2 = (e1 //-) <$> unification e1 e2 diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,8 +1,8 @@ -resolver: lts-15.5 # or ghc-8.8.3 +resolver: lts-17.9 # or ghc-8.10.4 packages: - . extra-deps: - leancheck-0.9.3 -- express-0.1.3 +- express-0.1.4 diff --git a/test/engine.hs b/test/engine.hs --- a/test/engine.hs +++ b/test/engine.hs @@ -14,11 +14,6 @@ tests :: Int -> [Bool] tests n = [ True - - , holds n $ \e -> mostGeneral e == head (fastCanonicalVariations e) - , holds n $ \e -> mostSpecific e == last (fastCanonicalVariations e) - , holds n $ \e -> allLater (\e1 e0 -> not (e0 `isInstanceOf` e1)) - $ fastCanonicalVariations e , equivalencesBetween (===) (i_ -+- i_) (i_ -+- i_) == [ ( xx -+- yy, yy -+- xx ) ] diff --git a/test/model/list-c-s4.out b/test/model/list-c-s4.out --- a/test/model/list-c-s4.out +++ b/test/model/list-c-s4.out @@ -36,44 +36,26 @@ _:tail [] :: [Int] _ ++ tail _ :: [Int] _ ++ tail [] :: [Int] -[] ++ tail _ :: [Int] -[] ++ tail [] :: [Int] head _:_ :: [Int] [head _] :: [Int] head []:_ :: [Int] [head []] :: [Int] tail _ ++ _ :: [Int] -tail _ ++ [] :: [Int] tail [] ++ _ :: [Int] -tail [] ++ [] :: [Int] head (tail (tail (tail _))) :: Int head (tail (tail (tail []))) :: Int head (tail (_ ++ _)) :: Int head (_ ++ tail _) :: Int head (_ ++ tail []) :: Int -head ([] ++ tail _) :: Int -head ([] ++ tail []) :: Int -head (head _:_) :: Int -head [head _] :: Int -head (head []:_) :: Int -head [head []] :: Int head (tail _ ++ _) :: Int -head (tail _ ++ []) :: Int head (tail [] ++ _) :: Int -head (tail [] ++ []) :: Int tail (tail (tail (tail _))) :: [Int] tail (tail (tail (tail []))) :: [Int] tail (tail (_ ++ _)) :: [Int] -tail (_:tail _) :: [Int] -tail (_:tail []) :: [Int] tail (_ ++ tail _) :: [Int] tail (_ ++ tail []) :: [Int] -tail ([] ++ tail _) :: [Int] -tail ([] ++ tail []) :: [Int] tail (tail _ ++ _) :: [Int] -tail (tail _ ++ []) :: [Int] tail (tail [] ++ _) :: [Int] -tail (tail [] ++ []) :: [Int] _:tail (tail _) :: [Int] _:tail (tail []) :: [Int] _:_:_ :: [Int] @@ -84,8 +66,6 @@ _ ++ (_:_) :: [Int] _ ++ [_] :: [Int] _ ++ (_ ++ _) :: [Int] -[] ++ tail (tail _) :: [Int] -[] ++ tail (tail []) :: [Int] head _:tail _ :: [Int] head _:tail [] :: [Int] head []:tail _ :: [Int] @@ -99,9 +79,7 @@ head (tail []):_ :: [Int] [head (tail [])] :: [Int] tail (tail _) ++ _ :: [Int] -tail (tail _) ++ [] :: [Int] tail (tail []) ++ _ :: [Int] -tail (tail []) ++ [] :: [Int] x :: Int xs :: [Int] @@ -771,7 +749,7 @@ tail (tail []) ++ ys :: [Int] tail (tail []) ++ zs :: [Int] -Number of Eq schema classes: 90 +Number of Eq schema classes: 68 Number of Eq 1-var classes: 68 Number of Eq 2-var classes: 191 Number of Eq 3-var classes: 406 diff --git a/test/model/list-c.out b/test/model/list-c.out --- a/test/model/list-c.out +++ b/test/model/list-c.out @@ -36,44 +36,26 @@ _:tail [] :: [Int] _ ++ tail _ :: [Int] _ ++ tail [] :: [Int] -[] ++ tail _ :: [Int] -[] ++ tail [] :: [Int] head _:_ :: [Int] [head _] :: [Int] head []:_ :: [Int] [head []] :: [Int] tail _ ++ _ :: [Int] -tail _ ++ [] :: [Int] tail [] ++ _ :: [Int] -tail [] ++ [] :: [Int] head (tail (tail (tail _))) :: Int head (tail (tail (tail []))) :: Int head (tail (_ ++ _)) :: Int head (_ ++ tail _) :: Int head (_ ++ tail []) :: Int -head ([] ++ tail _) :: Int -head ([] ++ tail []) :: Int -head (head _:_) :: Int -head [head _] :: Int -head (head []:_) :: Int -head [head []] :: Int head (tail _ ++ _) :: Int -head (tail _ ++ []) :: Int head (tail [] ++ _) :: Int -head (tail [] ++ []) :: Int tail (tail (tail (tail _))) :: [Int] tail (tail (tail (tail []))) :: [Int] tail (tail (_ ++ _)) :: [Int] -tail (_:tail _) :: [Int] -tail (_:tail []) :: [Int] tail (_ ++ tail _) :: [Int] tail (_ ++ tail []) :: [Int] -tail ([] ++ tail _) :: [Int] -tail ([] ++ tail []) :: [Int] tail (tail _ ++ _) :: [Int] -tail (tail _ ++ []) :: [Int] tail (tail [] ++ _) :: [Int] -tail (tail [] ++ []) :: [Int] _:tail (tail _) :: [Int] _:tail (tail []) :: [Int] _:_:_ :: [Int] @@ -84,8 +66,6 @@ _ ++ (_:_) :: [Int] _ ++ [_] :: [Int] _ ++ (_ ++ _) :: [Int] -[] ++ tail (tail _) :: [Int] -[] ++ tail (tail []) :: [Int] head _:tail _ :: [Int] head _:tail [] :: [Int] head []:tail _ :: [Int] @@ -99,9 +79,7 @@ head (tail []):_ :: [Int] [head (tail [])] :: [Int] tail (tail _) ++ _ :: [Int] -tail (tail _) ++ [] :: [Int] tail (tail []) ++ _ :: [Int] -tail (tail []) ++ [] :: [Int] x :: Int xs :: [Int] @@ -771,7 +749,7 @@ tail (tail []) ++ ys :: [Int] tail (tail []) ++ zs :: [Int] -Number of Eq schema classes: 90 +Number of Eq schema classes: 68 Number of Eq 1-var classes: 68 Number of Eq 2-var classes: 191 Number of Eq 3-var classes: 406 diff --git a/test/sdist b/test/sdist --- a/test/sdist +++ b/test/sdist @@ -2,7 +2,7 @@ # # test/sdist: tests the package generated by "cabal sdist". # -# Copyright (c) 2015-2020 Rudy Matela. +# Copyright (c) 2015-2021 Rudy Matela. # Distributed under the 3-Clause BSD licence. set -xe