more writing

Author: MaximilianAlgehed

docs/Manual.md

@@ -333,55 +333,39 @@ We can do a better job by constraining the condition using `genFromSpec`
 spec1 :: Specification (Int,Int,Int,Int)
 spec1 = constrained' $ \ w x y z -> [w <. x, x <. y, y <. z]
 
-prop2:: Gen Property
-prop2 = do
-   (w,x,y,z) <- genFromSpec spec1
-   pure $ (w < x && x < y && y < z) ==> property (w < z)
+prop2:: Property
+prop2 =
+  forAll (genFromSpec spec1) $ \(w,x,y,z)
+    (w < x && x < y && y < z) ==> property (w < z)
 ```
 
-Now the test passes.
+Now the test passes!
 
 ```
 ghci> quickCheck prop2
 +++ OK, passed 100 tests.
 ```
 
-Now this isn't a very good test either, since the precedent is alway true. A better solution would be to
-generate a mix, where the precedent is True most of the time, but sometimes False. Like this.
+The second interpretation of the specification is as a constraint checker, implemented as the function.
 
 ```haskell
-prop3:: Gen Property
-prop3 = do
-   (w,x,y,z) <- frequency [(9,genFromSpec spec1),(1,arbitrary)]
-   pure $ (w < x && x < y && y < z) ==> property (w < z)
-```
-
-Observe the result:
-
-```
-ghci> quickCheck prop3
-+++ OK, passed 100 tests; 7 discarded.
+conformsToSpec :: HasSpec a => a -> Specification a -> Bool
 ```
 
-The  `7 discarded` arises because in most random samples of `w`, `x`, `y`, and `z`, the ordering constraint will
-not be true, so a discard will occur. Because the ratio of constrained to random is 9 to 1, so the number
-of failures is small enough that we don't `give up`. The role of the `arbitrary` is to guard against the possibility
-that the constrained spec might be over constrained, and in that case will be values that will never be chosen in a random test.
-Which means we will not be choosing a good sample of the test space, so some bugs might escape detection.
-By adjusting the test so that any `arbitrary` samples, that are not ordered, pass the test, we identify
-a piuntin the sample space that the code does not handle correctly. In a later section we discuss how to use
-QuickChrck `classify` and `cover` write better tests.
-
-The purpose of constrained generators is to make it possible to write conditional 'implication' properties
-that have a high probability of not being vacuously true, and to combine this with other random
-techniques to make better samples of the test-space.
-
-The second interpretation of the specification is as a constraint checker, implemented as the function.
+Using this we can write a (admittedly silly) test that showcases this explicitly:
 
 ```haskell
-conformsToSpec :: HasSpec a => a -> Specification a -> Bool
+spec1 :: Specification (Int,Int,Int,Int)
+spec1 = constrained' $ \ w x y z -> [w <. x, x <. y, y <. z]
+
+prop2' :: Property
+prop2' =
+  forAll (genFromSpec spec1) $ \(w,x,y,z)
+    (w,x,y,z) `conformsToSpec` spec1 ==> property (w < z)
 ```
 
+Which similarly will always succeed and should never be discarded.
+
 ## How we solve the constraints
 
 Before we continue delving into how we use the library and the finer points