Haskell printf如何工作？

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

诀窍是使用类型类。对于printf，键是PrintfType类型类。它没有公开任何方法，但是重要的部分还是类型。

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

因此printf有一个重载的返回类型。在平凡的情况下，我们没有多余的参数，因此我们需要能够实例化r到IO ()。为此，我们有一个实例

instance PrintfType (IO ())

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