haskell - 跳棋和 EqProp

Question

我正在浏览 Haskell Book关于应用程序的章节开始使用 checkers用于测试的库。

这个库引入了EqProp类型类，我不明白它和Eq有什么区别。无论如何，大多数调用 EqProp 的示例都在后台使用 Eq。

为什么人们使用跳棋而不是 QuickCheck？

Answer 1

This library introduces the EqProp typeclass, and I don't understand how this differs from Eq.

Eq 中的

(==) 给你一个 Bool； EqProp 中的 (=-=) 为您提供了一个 QuickCheck Property。如果你有一个 Eq 的实例，你也可以使它成为一个 EqProp 实例，as witnessed by eq . EqProp 的有趣实例是那些不是 Eq 实例的实例，例如函数(参见 Li-yao Xia's answer )。

Why do people use checkers over Quickcheck?

Checkers 是一套基于 QuickCheck 的额外工具。作为其readme和 Hackage description建议，它的目标之一是使将类法则表示为 Quickcheck 属性变得容易。例如，请注意 the applicative "test batch" 的定义，我将在下面引用，看起来很像我们经常编写 Applicative 法则的方式，并且很好地 self 记录。

(随意跳过顶级签名中的簿记约束。另请注意，m (a,b,c) 参数是最简单的 -可能工作的方式，仅用于类型专门化，目的是您通过 undefined::[(Int,Int,Int)] 来测试 Applicative 的列表实例>.)

-- | Properties to check that the 'Applicative' @m@ satisfies the applicative
-- properties
applicative :: forall m a b c.
               ( Applicative m
               , Arbitrary a, CoArbitrary a, Arbitrary b, Arbitrary (m a)
               , Arbitrary (m (b -> c)), Show (m (b -> c))
               , Arbitrary (m (a -> b)), Show (m (a -> b))
               , Show a, Show (m a)
               , EqProp (m a), EqProp (m b), EqProp (m c)
               ) =>
               m (a,b,c) -> TestBatch
applicative = const ( "applicative"
                    , [ ("identity"    , property identityP)
                      , ("composition" , property compositionP)
                      , ("homomorphism", property homomorphismP)
                      , ("interchange" , property interchangeP)
                      , ("functor"     , property functorP)
                      ]
                    )
 where
   identityP     :: m a -> Property
   compositionP  :: m (b -> c) -> m (a -> b) -> m a -> Property
   homomorphismP :: (a -> b) -> a -> Property
   interchangeP  :: m (a -> b) -> a -> Property
   functorP      :: (a -> b) -> m a -> Property

   identityP v        = (pure id <*> v) =-= v
   compositionP u v w = (pure (.) <*> u <*> v <*> w) =-= (u <*> (v <*> w))
   homomorphismP f x  = (pure f <*> pure x) =-= (pure (f x) :: m b)
   interchangeP u y   = (u <*> pure y) =-= (pure ($ y) <*> u)
   functorP f x       = (fmap f x) =-= (pure f <*> x)