109

Haskell 的类型安全性在依赖类型语言中是首屈一指的。但是Text.Printf有一些深奥的魔力，看起来很奇怪。

> printf "%d\n" 3
3
> printf "%s %f %d" "foo" 3.3 3
foo 3.3 3

这背后的深层魔力是什么？函数如何Text.Printf.printf接受这样的可变参数？

在 Haskell 中允许可变参数的一般技术是什么，它是如何工作的？

（旁注：使用这​​种技术时，某些类型的安全性显然会丢失。）

> :t printf "%d\n" "foo"
printf "%d\n" "foo" :: (PrintfType ([Char] -> t)) => t
4

1 回答 1

133

诀窍是使用类型类。在 的情况下printf，关键是PrintfType类型类。它不公开任何方法，但重要的部分还是在类型中。

class PrintfType r
printf :: PrintfType r => String -> r

所以printf有一个重载的返回类型。在普通情况下，我们没有额外的参数，所以我们需要能够实例化r到IO (). 为此，我们有实例

instance PrintfType (IO ())

接下来，为了支持可变数量的参数，我们需要在实例级别使用递归。特别是我们需要一个实例，以便如果r是 a PrintfType，函数类型x -> r也是 a PrintfType。

-- instance PrintfType r => PrintfType (x -> r)

当然，我们只想支持实际可以格式化的参数。这就是第二种类型类的PrintfArg用武之地。所以实际的实例是

instance (PrintfArg x, PrintfType r) => PrintfType (x -> r)

这是一个简化版本，它在类中接受任意数量的参数Show并打印它们：

{-# LANGUAGE FlexibleInstances #-}

foo :: FooType a => a
foo = bar (return ())

class FooType a where
    bar :: IO () -> a

instance FooType (IO ()) where
    bar = id

instance (Show x, FooType r) => FooType (x -> r) where
    bar s x = bar (s >> print x)

在这里，bar采用递归构建的 IO 操作，直到没有更多参数为止，此时我们只需执行它。

*Main> foo 3 :: IO ()
3
*Main> foo 3 "hello" :: IO ()
3
"hello"
*Main> foo 3 "hello" True :: IO ()
3
"hello"
True

QuickCheck 也使用相同的技术，其中Testable类具有基本情况的实例Bool，以及在类中接受参数的函数的递归实例Arbitrary。

class Testable a
instance Testable Bool
instance (Arbitrary x, Testable r) => Testable (x -> r)
于 2011-10-19T21:49:39.030 回答