Как работает 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 ())

Затем, чтобы поддерживать переменное количество аргументов, нам нужно использовать рекурсию на уровне экземпляра. В частности, нам нужен экземпляр, чтобы if ris 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выполняется действие ввода-вывода, которое создается рекурсивно до тех пор, пока не будет больше аргументов, после чего мы просто выполняем его.

*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)