How does Haskell printf work?

by

The trick is to use type classes. In the case of printf, the key is the PrintfType type class. It does not expose any methods, but the important part is in the types anyway.

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

So printf has an overloaded return type. In the trivial case, we have no extra arguments, so we need to be able to instantiate r to IO (). For this, we have the instance

instance PrintfType (IO ())

Next, in order to support a variable number of arguments, we need to use recursion at the instance level. In particular we need an instance so that if r is a PrintfType, a function type x -> r is also a PrintfType.

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

Of course, we only want to support arguments which can actually be formatted. That’s where the second type class PrintfArg comes in. So the actual instance is

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

Here’s a simplified version which takes any number of arguments in the Show class and just prints them:

{-# 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)

Here, bar takes an IO action which is built up recursively until there are no more arguments, at which point we simply execute it.

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

QuickCheck also uses the same technique, where the Testable class has an instance for the base case Bool, and a recursive one for functions which take arguments in the Arbitrary class.

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

More Related Contents:

  1. How to create a polyvariadic haskell function?
  2. How do I define Lisp’s apply in Haskell?
  3. battleships game – Haskell [closed]
  4. What is a monad?
  5. Why shouldn’t I mix tabs and spaces?
  6. Does Haskell have tail-recursive optimization?
  7. Cartesian product of 2 lists in Haskell
  8. How to define a function in ghci across multiple lines?
  9. Memory footprint of Haskell data types
  10. Why does length return 1 for a tuple with 2 elements, and gives an error for a tuple with more elements?
  11. Finite comprehension of an infinite list
  12. Are there pronounceable names for common Haskell operators? [closed]
  13. Split a number into its digits with Haskell
  14. What indentation is required for a case statement within a let statement?
  15. What is the difference between Int and Integer?
  16. Is Haskell truly pure (is any language that deals with input and output outside the system)?
  17. Euler 43 – is there a monad to help write this list comprehension?
  18. Is there a way to place some impure code inside pure functions?
  19. How to increment a variable in functional programming?
  20. What part of Hindley-Milner do you not understand?
  21. Why is GHC complaining about non-exhaustive patterns?
  22. foldl Implementation with Runtime Errors
  23. Exception handling in Haskell
  24. How to make a type with restrictions
  25. Given a Haskell type signature, is it possible to generate the code automatically?
  26. Haskell Constraint is no smaller than the instance head
  27. Can I match a data constructor wildcard in Haskell?
  28. Is there, in Haskell, something similar to sub-guards?
  29. What is the Comonad typeclass in Haskell?
  30. Is Haskell’s mapM not lazy?

Leave a Comment