测试副作用单子的规律

Question

我正在编写一个库来通过 API 访问 Web 服务。我已经定义了简单的类来表示 API 操作

case class ApiAction[A](run: Credentials => Either[Error, A])

以及一些执行 Web 服务调用的函数

// Retrieve foo by id
def get(id: Long): ApiAction[Foo] = ???

// List all foo's
def list: ApiAction[Seq[Foo]] = ???

// Create a new foo
def create(name: String): ApiAction[Foo] = ???

// Update foo
def update(updated: Foo): ApiAction[Foo] = ???

// Delete foo
def delete(id: Long): ApiAction[Unit] = ???

我还把 ApiAction 做成了一个单子

implicit val monad = new Monad[ApiAction] { ... }

所以我可以做类似的事情

create("My foo").run(c)
get(42).map(changeFooSomehow).flatMap(update).run(c)
get(42).map(_.id).flatMap(delete).run(c)

现在我在测试它的单子定律时遇到了麻烦

val x = 42
val unitX: ApiAction[Int] = Monad[ApiAction].point(x)

"ApiAction" should "satisfy identity law" in {
  Monad[ApiAction].monadLaw.rightIdentity(unitX) should be (true)
}

因为monadLaw.rightIdentity 使用equal

def rightIdentity[A](a: F[A])(implicit FA: Equal[F[A]]): Boolean = 
  FA.equal(bind(a)(point(_: A)), a)

并且没有Equal[ApiAction]。

[error] could not find implicit value for parameter FA: scalaz.Equal[ApiAction[Int]]
[error]     Monad[ApiAction].monadLaw.rightIdentity(unitX) should be (true)
[error]                                            ^

问题是我什至无法想象如何定义Equal[ApiAction]。 ApiAction 本质上是一个函数，我不知道函数上有任何相等关系。当然可以比较运行ApiAction的结果，但是不一样。

我觉得我做的事情非常错误或不理解一些重要的事情。所以我的问题是：

• ApiAction 是一个 monad 有意义吗？
• ApiAction 是我设计的吗？
• 我应该如何测试它的单子定律？

Answer 1

我将从简单的开始：是的，ApiAction 是一个单子是有意义的。是的，你以合理的方式设计了它——这个设计看起来有点像 Haskell 中的 IO monad。

棘手的问题是你应该如何测试它。

唯一有意义的相等关系是“在给定相同输入的情况下产生相同的输出”，但这仅在纸面上真正有用，因为计算机无法验证，并且仅对纯函数有意义。实际上，Haskell 的 IO monad 与您的 monad 有一些相似之处，但没有实现 Eq。因此，如果您不实施Equal[ApiAction]，您可能会处于安全状态。

仍然可能有一个参数用于实现一个特殊的 Equal[ApiAction] 实例，仅用于测试，它使用硬编码的 Credentials 值（或少量硬编码值）运行操作并比较结果。从理论的角度来看，这很糟糕，但从实用的角度来看，它并不比使用测试用例测试更糟糕，并且可以让您重用 Scalaz 中现有的辅助函数。

另一种方法是忘记 Scalaz，使用铅笔和纸证明 ApiAction 满足 monad 定律，并编写一些测试用例来验证一切是否按照您认为的方式运行（使用您认为的方法）我写的，不是来自 Scalaz 的）。事实上，大多数人会跳过纸笔步骤。

Answer 2

归结为 lambdas 是 FunctionN 的匿名子类，其中只有实例相等，因此只有相同的匿名子类与自身相等。

关于如何做到这一点的一个想法： 使您的操作成为 Function1 的具体子类，而不是实例：

abstract class ApiAction[A] extends (Credentials => Either[Error, A])
// (which is the same as)
abstract class ApiAction[A] extends Function1[Credentials, Either[Error, A]]

这将允许您例如为您的实例创建案例对象

case class get(id: Long) extends ApiAction[Foo] {
  def apply(creds: Credentials): Either[Error, Foo] = ... 
}

这反过来应该允许您以适合您的方式为 ApiAction 的每个子类实现 equals，例如在构造函数的参数上。 （你可以像我一样免费获得操作案例类）

val a = get(1)
val b = get(1)
a == b

您也可以这样做，而无需像我一样扩展 Function1 并像您一样使用运行字段，但这种方式提供了最简洁的示例代码。

Answer 3

我认为您可以通过必须使用宏或反射将您的函数包装到包含 AST 的类中的缺点来实现它。然后，您可以通过比较它们的 AST 来比较两个函数。

见What's the easiest way to use reify (get an AST of) an expression in Scala?