Haskell：如何将接口与实现分离

Question

我知道有两种方法可以在 Haskell 中将接口规范与该接口的实现分开：

1. 类型类，例如：

   • 接口：RandomGen
   • 实现：StdGen

2. 记录，例如：

   • 接口：Network.Transport
   • 实现：Network.Transport.TCP

问题 1：什么时候适合使用其中一种？

问题 2：在 Haskell 中还有哪些其他方法可以分离接口/实现？

Answer 1

问题 1 的答案非常简单：这两个选项是等价的——类型类可以“脱糖”为数据类型。这个想法已在http://www.haskellforall.com/2012/05/scrap-your-type-classes.html 中进行了描述和论证。

---

问题 2 的答案是，这两个是唯一将接口与实现分开的方法。推理是这样的：

1. 最终的目标是以某种方式传递函数——这是因为在 Haskell 中除了函数之外没有其他方法可以实现任何东西，所以为了传递实现，你需要传递函数（注意规范是只是类型）
2. 您可以传递单个函数或多个函数
3. 要传递单个函数，您只需传递该函数，或者将该函数包装在某些东西中以模仿类型类（即，除了类型签名（@ 987654323@)
4. 要传递多个函数，您只需在元组或记录中传递它们（如我们的CanFoo，但有更多字段）；请注意，在这种情况下，记录只是具有命名字段的命名元组类型。

——无论是显式传递还是隐式传递函数（使用类型类），正如已经证明的，在概念上是一回事^[1]。

---

以下是这两种方法如何等效的简单演示：

data Foo = Foo

-- using type classes
class CanFoo a where
  foo :: a -> Foo

doFoo :: CanFoo a => a -> IO Foo
doFoo a = do
  putStrLn "hello"
  return $ foo a

instance CanFoo Int where
  foo _ = Foo

main = doFoo 3

-- using explicit instance passing
data CanFoo' a = CanFoo' { foo :: a -> Foo }

doFoo' :: CanFoo' a -> a -> IO Foo
doFoo' cf a = do
  putStrLn "hello"
  return $ (foo cf) a

intCanFoo = CanFoo { foo = \_ -> Foo }

main' = doFoo' intCanFoo 3

如您所见，如果您使用记录，您的“实例”将不再自动查找，而是需要将它们显式传递给需要它们的函数。

还请注意，在普通情况下，记录方法可以简化为仅传递函数，因为传递 CanFoo { foo = \_ -> Foo } 与传递包装函数 \_ -> Foo 本身实际上是相同的。

---

[1]

事实上，在 Scala 中，这种概念上的等价性变得很明显，因为 Scala 中的类型类是根据类型（例如 trait CanFoo[T]）、该类型的许多值以及该类型的函数参数进行编码的标记为implicit，这将导致Scala 在调用站点查找CanFoo[Int] 类型的值。

// data Foo = Foo
case object Foo

// data CanFoo t = CanFoo { foo :: t -> Foo }
trait CanFoo[T] { def foo(x : T): Foo }
object CanFoo {
  // intCanFoo = CanFoo { foo = \_ -> Foo }
  implicit val intCanFoo = new CanFoo[Int] { def foo(_: Int) = Foo }
}

object MyApp {
  // doFoo :: CanFoo Int -> Int -> IO ()
  def doFoo(someInt: Int)(implicit ev : CanFoo[Int]] = {
    println("hello")
    ev.foo(someInt)
  }

  def main(args : List[String]) = {
    doFoo(3)
  }
}