Question

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

Answer 1

诀窍是使用类型类。对于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类中接受参数的函数。 / p>

class Testable a
instance Testable Bool
instance (Arbitrary x, Testable r) => Testable (x -> r)

Haskell printf如何工作？

1 个答案: