speculate alternatives and similar packages
Based on the "Testing" category.
Alternatively, view speculate alternatives based on common mentions on social networks and blogs.

hedgehog
Release with confidence, stateoftheart property testing for Haskell. 
quickcheckstatemachine
Test monadic programs using state machine based models 
curlrunnings
A declarative test framework for quickly and easily writing integration tests against JSON API's. 
smallcheck
Test your Haskell code by exhaustively checking its properties 
ghcprofflamegraph
Generates data to be used with flamegraph.pl from .prof files. 
monadmock
A Haskell package that provides a monad transformer for mocking mtlstyle typeclasses 
fuzzcheck
A library for testing monadic code in the spirit of QuickCheck 
testframework
Framework for running and organising QuickCheck test properties and HUnit test cases 
tastyhedgehog
Tasty integration for the Hedgehog property testing library 
quickcheckarbitraryadt
Typeclass for generating a list of each instance of a sum type's constructors 
shouldnottypecheck
A HUnit/hspec assertion to verify that an expression does not typecheck 
hspecgoldenaeson
Use tests to monitor changes in Aeson serialization 
hspecexpectationsjson
Hspec expectations on JSON Values 
markovchainusagemodel
Computations for Markov chain usage models 
tastyrerun
Rerun previous test suite runs to run only failing tests 
testframeworksandbox
testsandbox support for the testframework package 
testframeworkth
Automagically (using Template Haskell) generates the Haskellcode you need when using HUnit 
tastyexpectedfailure
Mark test cases as expectedfailure 
quickcheckarbitrarytemplate
Arbitrary QuickCheck instance generation using template haskell
Scout APM  Leadingedge performance monitoring starting at $39/month
Do you think we are missing an alternative of speculate or a related project?
README
Speculate
Speculate automatically discovers laws about Haskell functions. 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
;  conditional equations, such as
x <= 0 ==> x + abs x == 0
.
Speculate is similar to, and inspired by, QuickSpec.
Installing Speculate
To install the latest Speculate version from Hackage, just:
$ cabal update
$ cabal install speculate
Prerequisites are cmdargs, express and leancheck. They should be automatically resolved and installed by Cabal.
Using Speculate
Speculate is used as a library: import it, then call the function speculate
with relevant arguments. The following program Speculates about the
functions (+)
and abs
:
import Test.Speculate
main :: IO ()
main = speculate args
{ constants =
[ showConstant (0::Int)
, showConstant (1::Int)
, constant "+" ((+) :: Int > Int > Int)
, constant "abs" (abs :: Int > Int)
]
}
when run, it prints the following:
_ :: Int (holes: Int)
0 :: Int
1 :: Int
(+) :: Int > Int > Int
abs :: Int > Int
abs (abs x) == abs x
x + 0 == x
x + y == y + x
(x + y) + z == x + (y + z)
abs (x + abs x) == x + abs x
abs x + abs x == abs (x + x)
abs (1 + abs x) == 1 + abs x
x <= abs x
0 <= abs x
x <= x + 1
Now, if we add <=
and <
as background constants on args
, constants =
[ showConstant (0::Int)
, showConstant (1::Int)
, constant "+" ((+) :: Int > Int > Int)
, constant "abs" (abs :: Int > Int)
, background
, constant "<=" ((<=) :: Int > Int > Bool)
, constant "<" ((<) :: Int > Int > Bool)
]
then run again, we get the following as well:
y <= x ==> abs (x + abs y) == x + abs y
x <= 0 ==> x + abs x == 0
abs x <= y ==> abs (x + y) == x + y
abs y <= x ==> abs (x + y) == x + y
For more examples, see the [eg](eg) folder.
Similarities and Differences to QuickSpec
Speculate is inspired by QuickSpec. Like QuickSpec, Speculate uses testing to speculate equational laws about given Haskell functions. There are some differences:
 Speculate tests enumeratively using LeanCheck, QuickSpec tests randomly using QuickCheck;
 Speculate is able to report inequalities directly;
 QuickSpec allows polymorphism, Speculate does not;
 For most examples, Speculate runs slower than QuickSpec 2 but faster than QuickSpec 1.
More documentation
For more examples, see the [eg](eg) and [bench](bench) folders.
Speculate has been subject to a paper, see the Speculate Paper on Haskell Symposium 2017. Speculate is also subject to a chapter in a PhD Thesis (2017).