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, state-of-the-art property testing for Haskell. -
quickcheck-state-machine
Test monadic programs using state machine based models -
curl-runnings
A declarative test framework for quickly and easily writing integration tests against JSON APIs. -
smallcheck
Test your Haskell code by exhaustively checking its properties -
ghc-prof-flamegraph
Generates data to be used with flamegraph.pl from .prof files. -
monad-mock
A Haskell package that provides a monad transformer for mocking mtl-style typeclasses -
test-framework
Framework for running and organising QuickCheck test properties and HUnit test cases -
tasty-hedgehog
Tasty integration for the Hedgehog property testing library -
fuzzcheck
A library for testing monadic code in the spirit of QuickCheck -
should-not-typecheck
A HUnit/hspec assertion to verify that an expression does not typecheck -
hspec-expectations-json
Hspec expectations on JSON Values -
hspec-golden-aeson
Use tests to monitor changes in Aeson serialization -
quickcheck-arbitrary-adt
Typeclass for generating a list of each instance of a sum type's constructors -
tasty-expected-failure
Mark test cases as expected-failure -
test-framework-th
Automagically (using Template Haskell) generates the Haskell-code you need when using HUnit -
tasty-ant-xml
A tasty ingredient to output test results in XML, using the Ant schema. This XML can be consumed by the Jenkins continuous integration framework. -
test-framework-sandbox
test-sandbox support for the test-framework package -
tasty-rerun
Rerun previous test suite runs to run only failing tests
WorkOS - The modern identity platform for B2B SaaS
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
Pre-requisites 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).