Skip to main content

Differences to Haskell Hedgehog

Differences to Haskell Hedgehog

This page documents where the Scala Hedgehog API deviates significantly from the Haskell version.


The Haskell version allow for assertions throughout the Property monad, but the final value is ().

prop_reverse :: Property
prop_reverse =
property $ do
xs <- forAll $ Gen.list (Range.linear 0 100) Gen.alpha
reverse (reverse xs) === xs

And the corresponding Scala version:

def propReverse: Property =
for {
xs <- Gen.alpha.list(Range.linear(0, 100)).forAll
} yield xs.reverse.reverse ==== xs

Resource Management

This approach makes it more difficult to isolate resource management in a strict language like Scala. It then becomes fairly important in the Haskell version to use ResourceT:

prop_unix_sort :: Property
prop_unix_sort =
property $ do
values0 <- forAll $ Gen.list (Range.linear 0 100) Gen.alpha
test . runResourceT $ do
dir <- Temp.createTempDirectory Nothing "prop_dir"
values0 === values

To simplify this, and to reduce surprises, the final result in the Scala version is now a separate Result value, which forces a single, final assertion to be returned.

def propUnixSort: Property =
for {
values0 <- Gen.alpha.list(Range.linear(0, 100)).forAll
} yield {
val dir =
try {
values0 ==== values
} finally {

Property Plus Example

The Scala version has an additional data type that allows generators to be applied to the final "test" in a way that can be invoked from by consumers.

def propReverse: PropertyR[List[Char]] =
Gen.alpha.list(Range.linear(0, 100)).forAll
)(xs => xs.reverse.reverse ==== xs)

Here is an example of re-using the same method with both a property and a "golden" example test:

  def tests: List[Test] =
, example(propReverse.test(List('a', 'b', 'c')))

Monadic Gen

One of the original goals of the Haskell implementation was to support completely generic monadic values.

Generators allow monadic effects.

For example you could use a StateT as part of the generator. In a strict language like Scala the Monad is also critical for providing a lazy tree. However, putting the laziness on each tree node results in serious memory problems. For now we have had to move this laziness to the tree children.

In practice I doubt that many people are seriously using monadic effects for generated values, and I'm happy to revisit this if/when an issue is raised.

State Vars

The Haskell State testing uses a very powerful Symbolic and Concrete types to represent the different states of a variable when implementing the Command interface.

While this is technically possible in Scala, the types are quite intimidating, especially HTraversable. Instead we opt for a lower-level variable "lookup" by passing in the Environment map where concrete variables are available, so that users can resolve them manually.