diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,5 @@
+6.0.0
+
+* Changed the type of `Format`. Now you write `Format r (a -> r)` instead
+  of `Format a`.
+* Add `formatToString` function.
diff --git a/formatting.cabal b/formatting.cabal
--- a/formatting.cabal
+++ b/formatting.cabal
@@ -1,5 +1,5 @@
 name:                formatting
-version:             5.4
+version:             6.0.0
 synopsis:            Combinator-based type-safe formatting (like printf() or FORMAT)
 description:         Combinator-based type-safe formatting (like printf() or FORMAT), modelled from the HoleyMonoids package.
 license:             BSD3
@@ -10,6 +10,7 @@
 category:            Text
 build-type:          Simple
 cabal-version:       >=1.8
+extra-source-files:  CHANGELOG.md
 
 library
   exposed-modules:   Formatting,
diff --git a/src/Formatting.hs b/src/Formatting.hs
--- a/src/Formatting.hs
+++ b/src/Formatting.hs
@@ -29,7 +29,9 @@
   hprint,
   -- * Formatting library
   module Formatting.Holey,
-  module Formatting.Formatters
+  module Formatting.Formatters,
+  -- * Other functions
+  formatToString
  ) where
 
 import Formatting.Formatters
diff --git a/src/Formatting/Formatters.hs b/src/Formatting/Formatters.hs
--- a/src/Formatting/Formatters.hs
+++ b/src/Formatting/Formatters.hs
@@ -74,15 +74,15 @@
 import           Data.Scientific
 
 -- | Output a lazy text.
-text :: Format Text
+text :: Format r (Text -> r)
 text = later T.fromLazyText
 
 -- | Output a strict text.
-stext :: Format S.Text
+stext :: Format r (S.Text -> r)
 stext = later T.fromText
 
 -- | Output a string.
-string :: Format String
+string :: Format r (String -> r)
 string = later (T.fromText . T.pack)
 
 -- | Output a showable value (instance of 'Show') by turning it into
@@ -90,87 +90,87 @@
 --
 -- >>> format ("Value number " % shown % " is " % shown % ".") 42 False
 -- "Value number 42 is False."
-shown :: Show a => Format a
+shown :: Show a => Format r (a -> r)
 shown = later (T.fromText . T.pack . show)
 
 -- | Output a character.
-char :: Format Char
+char :: Format r (Char -> r)
 char = later B.build
 
 -- | Build a builder.
-builder :: Format Builder
+builder :: Format r (Builder -> r)
 builder = later id
 
 -- | Like `const` but for formatters.
-fconst :: Builder -> Format a
+fconst :: Builder -> Format r (a -> r)
 fconst m = later (const m)
 
 -- | Build anything that implements the "Buildable" class.
-build :: Buildable a => Format a
+build :: Buildable a => Format r (a -> r)
 build = later B.build
 
 -- | Render an integral e.g. 123 -> \"123\", 0 -> \"0\".
-int :: Integral a => Format a
+int :: Integral a => Format r (a -> r)
 int = later T.shortest
 
 -- | Render some floating point with the usual notation, e.g. 123.32 => \"123.32\"
-float :: Real a => Format a
+float :: Real a => Format r (a -> r)
 float = later (T.shortest)
 
 -- | Render a floating point number using scientific/engineering
 -- notation (e.g. 2.3e123), with the given number of decimal places.
-expt :: Real a => Int -> Format a
+expt :: Real a => Int -> Format r (a -> r)
 expt i = later (T.expt i)
 
 -- | Render a floating point number using normal notation, with the
 -- given number of decimal places.
-fixed :: Real a => Int -> Format a
+fixed :: Real a => Int -> Format r (a -> r)
 fixed i = later (T.fixed i)
 
 -- | Render a floating point number, with the given number of digits
 -- of precision. Uses decimal notation for values between 0.1 and
 -- 9,999,999, and scientific notation otherwise.
-prec :: Real a => Int -> Format a
+prec :: Real a => Int -> Format r (a -> r)
 prec i = later (T.prec i)
 
 -- | Render a floating point number using the smallest number of
 -- digits that correctly represent it.
-shortest :: Real a => Format a
+shortest :: Real a => Format r (a -> r)
 shortest = later T.shortest
 
 -- | Render a scientific number.
-sci :: Format Scientific
+sci :: Format r (Scientific -> r)
 sci = later scientificBuilder
 
 -- | Render a scientific number with options.
-scifmt :: FPFormat -> Maybe Int -> Format Scientific
+scifmt :: FPFormat -> Maybe Int -> Format r (Scientific -> r)
 scifmt f i = later (formatScientificBuilder f i)
 
 -- | Shows the Int value of Enum instances using 'fromEnum'.
 --
 -- >>> format ("Got: " % char % " (" % asInt % ")") 'a' 'a'
 -- "Got: a (97)"
-asInt :: Enum a => Format a
+asInt :: Enum a => Format r (a -> r)
 asInt = later (T.shortest . fromEnum)
 
 -- | Pad the left hand side of a string until it reaches k characters
 -- wide, if necessary filling with character c.
-left :: Buildable a => Int -> Char -> Format a
+left :: Buildable a => Int -> Char -> Format r (a -> r)
 left i c = later (T.left i c)
 
 -- | Pad the right hand side of a string until it reaches k characters
 -- wide, if necessary filling with character c.
-right :: Buildable a => Int -> Char -> Format a
+right :: Buildable a => Int -> Char -> Format r (a -> r)
 right i c = later (T.right i c)
 
 -- | Pad the left & right hand side of a string until it reaches k characters
 -- wide, if necessary filling with character c.
-center :: Buildable a => Int -> Char -> Format a
+center :: Buildable a => Int -> Char -> Format r (a -> r)
 center i c = later centerT where
   centerT = T.fromLazyText . LT.center (fromIntegral i) c . T.toLazyText . B.build
 
 -- | Group integral numbers, e.g. groupInt 2 '.' on 123456 -> \"12.34.56\".
-groupInt :: (Buildable n,Integral n) => Int -> Char -> Format n
+groupInt :: (Buildable n,Integral n) => Int -> Char -> Format r (n -> r)
 groupInt 0 _ = later B.build
 groupInt i c = later (commaize)
   where commaize =
@@ -190,12 +190,12 @@
         cycle' xs = xs <> cycle' xs
 
 -- | Fit in the given length, truncating on the left.
-fitLeft :: Buildable a => Int -> Format a
+fitLeft :: Buildable a => Int -> Format r (a -> r)
 fitLeft size = later (fit (fromIntegral size)) where
   fit i = T.fromLazyText . LT.take i . T.toLazyText . B.build
 
 -- | Fit in the given length, truncating on the right.
-fitRight :: Buildable a => Int -> Format a
+fitRight :: Buildable a => Int -> Format r (a -> r)
 fitRight size = later (fit (fromIntegral size)) where
   fit i = T.fromLazyText .
           (\t -> LT.drop (LT.length t - i) t)
@@ -203,11 +203,11 @@
           . B.build
 
 -- | Add commas to an integral, e.g 12000 -> \ "12,000".
-commas :: (Buildable n,Integral n) => Format n
+commas :: (Buildable n,Integral n) => Format r (n -> r)
 commas = groupInt 3 ','
 
 -- | Add a suffix to an integral, e.g. 1st, 2nd, 3rd, 21st.
-ords :: Integral n => Format n
+ords :: Integral n => Format r (n -> r)
 ords = later go
   where go n
           | tens > 3 && tens < 21 = T.shortest n <> "th"
@@ -221,43 +221,43 @@
           where tens = n `mod` 100
 
 -- | English plural suffix for an integral.
-plural :: (Num a, Eq a) => Text -> Text -> Format a
+plural :: (Num a, Eq a) => Text -> Text -> Format r (a -> r)
 plural s p = later (\i -> if i == 1 then B.build s else B.build p)
 
 -- | Render an integral at base n.
-base :: Integral a => Int -> Format a
+base :: Integral a => Int -> Format r (a -> r)
 base numBase = later (B.build . atBase numBase)
 
 -- | Render an integer using binary notation. (No leading 0b is
 -- added.) Defined as @bin = 'base' 2@.
-bin :: Integral a => Format a
+bin :: Integral a => Format r (a -> r)
 bin = base 2
 {-# INLINE bin #-}
 
 -- | Render an integer using octal notation. (No leading 0o is
 -- added.) Defined as @oct = 'base' 8@.
-oct :: Integral a => Format a
+oct :: Integral a => Format r (a -> r)
 oct = base 8
 {-# INLINE oct #-}
 
 -- | Render an integer using hexadecimal notation. (No leading 0x is
 -- added.) Has a specialized implementation.
-hex :: Integral a => Format a
+hex :: Integral a => Format r (a -> r)
 hex = later T.hex
 {-# INLINE hex #-}
 
 -- | Render an integer using binary notation with a leading 0b.
-prefixBin :: Integral a => Format a
+prefixBin :: Integral a => Format r (a -> r)
 prefixBin = "0b" % bin
 {-# INLINE prefixBin #-}
 
 -- | Render an integer using octal notation with a leading 0o.
-prefixOct :: Integral a => Format a
+prefixOct :: Integral a => Format r (a -> r)
 prefixOct = "0o" % oct
 {-# INLINE prefixOct #-}
 
 -- | Render an integer using hexadecimal notation with a leading 0x.
-prefixHex :: Integral a => Format a
+prefixHex :: Integral a => Format r (a -> r)
 prefixHex = "0x" % hex
 {-# INLINE prefixHex #-}
 
diff --git a/src/Formatting/Holey.hs b/src/Formatting/Holey.hs
--- a/src/Formatting/Holey.hs
+++ b/src/Formatting/Holey.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE TypeSynonymInstances #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE GADTs #-}
@@ -32,7 +33,7 @@
 import Data.Text.Lazy.Builder (Builder)
 
 -- | A formatter.
-type Format a = forall r. Holey Builder r (a -> r)
+type Format r x = Holey Builder r x
 
 -- | The type of a monoid with holes. The underlying monoid is
 -- represented by type parameter @m@. The @r@ is the result type and
@@ -50,28 +51,28 @@
   fmap g m = Holey (\k -> runHM m (k . g))
 
 -- | Very useful instance for writing format string.
-instance (IsString m, a ~ r) => IsString (Holey m r a) where
+instance (a ~ r) => IsString (Format r a) where
   fromString = now . fromString
 
 -- | Composition operator. The same as category composition.
-(%) :: Monoid n => Holey n b c -> Holey n b1 b -> Holey n b1 c
+(%) :: Format b c -> Format r b -> Format r c
 f % g = f `bind` \a -> g `bind` \b -> now (a `mappend` b)
 
 -- | Function compose two holeys. Will feed the result of one holey
 -- into another.
-(%.) :: Holey m r (a -> b) -> Holey a b c -> Holey m r c
+(%.) :: Format r (Builder -> b) -> Format b c -> Format r c
 (%.) (Holey a) (Holey b) = Holey (b . a)
 
 -- | Insert a constant monoidal value.
-now :: m -> Holey m r r
+now :: Builder -> Format r r
 now a = Holey ($ a)
 
 -- | Monadic indexed bind for holey monoids.
-bind :: Holey m b c -> (m -> Holey n a b) -> Holey n a c
+bind :: Format b c -> (Builder -> Format a b) -> Format a c
 m `bind` f = Holey $ \k -> runHM m (\a -> runHM (f a) k)
 
 -- | Insert a monoidal value that is not specified until the
 -- computation is 'run'. The argument that is expected later is
 -- converted to the monoid type using the given conversion function.
-later :: (a -> m) -> Holey m r (a -> r)
+later :: (a -> Builder) -> Format r (a -> r)
 later f = Holey (. f)
diff --git a/src/Formatting/Internal.hs b/src/Formatting/Internal.hs
--- a/src/Formatting/Internal.hs
+++ b/src/Formatting/Internal.hs
@@ -4,6 +4,8 @@
 
 import           Formatting.Holey
 
+import qualified Data.Text.Lazy as TL
+import qualified Data.Text.Lazy.Builder as TLB
 import qualified Data.Text as S (Text)
 import           Data.Text.Lazy (Text)
 import qualified Data.Text.Lazy as T
@@ -13,21 +15,25 @@
 import           System.IO
 
 -- | Run the formatter and return a lazy 'Text' value.
-format :: Holey Builder Text a -> a
+format :: Format Text a -> a
 format m = runHM m T.toLazyText
 
 -- | Run the formatter and return a strict 'S.Text' value.
-sformat :: Holey Builder S.Text a -> a
+sformat :: Format S.Text a -> a
 sformat m = runHM m (T.toStrict . T.toLazyText)
 
 -- | Run the formatter and return a 'Builder' value.
-bprint :: Holey Builder Builder a -> a
+bprint :: Format Builder a -> a
 bprint m = runHM m id
 
 -- | Run the formatter and print out the text to stdout.
-fprint :: Holey Builder (IO ()) a -> a
+fprint :: Format (IO ()) a -> a
 fprint m = runHM m (T.putStr . T.toLazyText)
 
 -- | Run the formatter and put the output onto the given 'Handle'.
-hprint :: Handle -> Holey Builder (IO ()) a -> a
+hprint :: Handle -> Format (IO ()) a -> a
 hprint h m = runHM m (T.hPutStr h . T.toLazyText)
+
+-- | Run the formatter and return a list of characters.
+formatToString :: Format [Char] a -> a
+formatToString m = runHM m (TL.unpack . TLB.toLazyText)
diff --git a/src/Formatting/ShortFormatters.hs b/src/Formatting/ShortFormatters.hs
--- a/src/Formatting/ShortFormatters.hs
+++ b/src/Formatting/ShortFormatters.hs
@@ -27,71 +27,71 @@
 import qualified Data.Text.Lazy.Builder as T
 
 -- | Output a lazy text.
-t :: Format Text
+t :: Format r (Text -> r)
 t = later T.fromLazyText
 
 -- | Render an integral e.g. 123 -> \"123\", 0 -> \"0\".
-d :: Integral a => Format a
+d :: Integral a => Format r (a -> r)
 d = int
 
 -- | Render an integer using binary notation. (No leading 0b is
 -- added.)
-b :: Integral a => Format a
+b :: Integral a => Format r (a -> r)
 b = bin
 
 -- | Render an integer using octal notation. (No leading 0o is added.)
-o :: Integral a => Format a
+o :: Integral a => Format r (a -> r)
 o = oct
 
 -- | Render an integer using hexadecimal notation. (No leading 0x is
 -- added.)
-x :: Integral a => Format a
+x :: Integral a => Format r (a -> r)
 x = later T.hex
 
 -- | Output a strict text.
-st :: Format S.Text
+st :: Format r (S.Text -> r)
 st = later T.fromText
 
 -- | Output a string.
-s :: Format String
+s :: Format r (String -> r)
 s = later (T.fromText . T.pack)
 
 -- | Output a showable value (instance of 'Show') by turning it into
 -- 'Text'.
-sh :: Show a => Format a
+sh :: Show a => Format r (a -> r)
 sh = later (T.fromText . T.pack . show)
 
 -- | Output a character.
-c :: Format Char
+c :: Format r (Char -> r)
 c = later B.build
 
 -- | Render a floating point number using scientific/engineering
 -- notation (e.g. 2.3e123), with the given number of decimal places.
-ef :: Real a => Int -> Format a
+ef :: Real a => Int -> Format r (a -> r)
 ef i = later (T.expt i)
 
 -- | Render a floating point number using normal notation, with the
 -- given number of decimal places.
-f :: Real a => Int -> Format a
+f :: Real a => Int -> Format r (a -> r)
 f i = later (T.fixed i)
 
 -- | Render a floating point number, with the given number of digits
 -- of precision. Uses decimal notation for values between 0.1 and
 -- 9,999,999, and scientific notation otherwise.
-pf :: Real a => Int -> Format a
+pf :: Real a => Int -> Format r (a -> r)
 pf i = later (T.prec i)
 
 -- | Render a floating point number using the smallest number of
 -- digits that correctly represent it.
-sf :: Real a => Format a
+sf :: Real a => Format r (a -> r)
 sf = later T.shortest
 
 -- | Pad the left hand side of a string until it reaches @k@ characters
 -- wide, if necessary filling with character @ch@.
-l :: Buildable a => Int -> Char -> Format a
+l :: Buildable a => Int -> Char -> Format r (a -> r)
 l i ch = later (T.left i ch)
 
 -- | Pad the right hand side of a string until it reaches @k@ characters
 -- wide, if necessary filling with character @ch@.
-r :: Buildable a => Int -> Char -> Format a
+r :: Buildable a => Int -> Char -> Format r (a -> r)
 r i ch = later (T.right i ch)
diff --git a/src/Formatting/Time.hs b/src/Formatting/Time.hs
--- a/src/Formatting/Time.hs
+++ b/src/Formatting/Time.hs
@@ -20,77 +20,77 @@
 -- * For 'TimeZone' (and 'ZonedTime' and 'UTCTime'):
 
 -- | Timezone offset on the format @-HHMM@.
-tz :: FormatTime a => Format a
+tz :: FormatTime a => Format r (a -> r)
 tz = later (build . fmt "%z")
 
 -- | Timezone name.
-tzName :: FormatTime a => Format a
+tzName :: FormatTime a => Format r (a -> r)
 tzName = later (build . fmt "%Z")
 
 -- | As 'dateTimeFmt' @locale@ (e.g. @%a %b %e %H:%M:%S %Z %Y@).
-datetime :: FormatTime a => Format a
+datetime :: FormatTime a => Format r (a -> r)
 datetime = later (build . fmt "%c")
 
 -- * For 'TimeOfDay' (and 'LocalTime' and 'ZonedTime' and 'UTCTime'):
 
 -- | Same as @%H:%M@.
-hm :: FormatTime a => Format a
+hm :: FormatTime a => Format r (a -> r)
 hm = later (build . fmt "%R")
 
 -- | Same as @%H:%M:%S@.
-hms :: FormatTime a => Format a
+hms :: FormatTime a => Format r (a -> r)
 hms = later (build . fmt "%T")
 
 -- | As 'timeFmt' @locale@ (e.g. @%H:%M:%S@).
-hmsL :: FormatTime a => Format a
+hmsL :: FormatTime a => Format r (a -> r)
 hmsL = later (build . fmt "%X")
 
 -- | As 'time12Fmt' @locale@ (e.g. @%I:%M:%S %p@).
-hmsPL :: FormatTime a => Format a
+hmsPL :: FormatTime a => Format r (a -> r)
 hmsPL = later (build . fmt "%r")
 
 -- | Day half from ('amPm' @locale@), converted to lowercase, @am@,
 -- @pm@.
-dayHalf :: FormatTime a => Format a
+dayHalf :: FormatTime a => Format r (a -> r)
 dayHalf = later (build . fmt "%P")
 
 -- | Day half from ('amPm' @locale@), @AM@, @PM@.
-dayHalfU :: FormatTime a => Format a
+dayHalfU :: FormatTime a => Format r (a -> r)
 dayHalfU = later (build . fmt "%p")
 
 -- | Hour, 24-hour, leading 0 as needed, @00@ - @23@.
-hour24 :: FormatTime a => Format a
+hour24 :: FormatTime a => Format r (a -> r)
 hour24 = later (build . fmt "%H")
 
 -- | Hour, 12-hour, leading 0 as needed, @01@ - @12@.
-hour12 :: FormatTime a => Format a
+hour12 :: FormatTime a => Format r (a -> r)
 hour12 = later (build . fmt "%I")
 
 -- | Hour, 24-hour, leading space as needed, @ 0@ - @23@.
-hour24S :: FormatTime a => Format a
+hour24S :: FormatTime a => Format r (a -> r)
 hour24S = later (build . fmt "%k")
 
 -- | Hour, 12-hour, leading space as needed, @ 1@ - @12@.
-hour12S :: FormatTime a => Format a
+hour12S :: FormatTime a => Format r (a -> r)
 hour12S = later (build . fmt "%l")
 
 -- | Minute, @00@ - @59@.
-minute :: FormatTime a => Format a
+minute :: FormatTime a => Format r (a -> r)
 minute = later (build . fmt "%M")
 
 -- | Second, without decimal part, @00@ - @60@.
-second :: FormatTime a => Format a
+second :: FormatTime a => Format r (a -> r)
 second = later (build . fmt "%S")
 
 -- | Picosecond, including trailing zeros, @000000000000@ -
 -- @999999999999@.
-pico :: FormatTime a => Format a
+pico :: FormatTime a => Format r (a -> r)
 pico = later (build . fmt "%q")
 
 -- | Decimal point and up to 12 second decimals, without trailing
 -- zeros. For a whole number of seconds, this produces the empty
 -- string.
-decimals :: FormatTime a => Format a
+decimals :: FormatTime a => Format r (a -> r)
 decimals = later (build . fmt "%Q")
 
 -- * For 'UTCTime' and 'ZonedTime'
@@ -99,110 +99,110 @@
 -- the Unix epoch, this is a negative number. Note that in @%s.%q@ and @%s%Q@
 -- the decimals are positive, not negative. For example, 0.9 seconds
 -- before the Unix epoch is formatted as @-1.1@ with @%s%Q@.
-epoch :: FormatTime a => Format a
+epoch :: FormatTime a => Format r (a -> r)
 epoch = later (build . fmt "%s")
 
 -- * For 'Day' (and 'LocalTime' and 'ZonedTime' and 'UTCTime'):
 
 -- | Same as @%m\/%d\/%y@.
-dateSlash :: FormatTime a => Format a
+dateSlash :: FormatTime a => Format r (a -> r)
 dateSlash = later (build . fmt "%D")
 
 -- | Same as @%Y-%m-%d@.
-dateDash :: FormatTime a => Format a
+dateDash :: FormatTime a => Format r (a -> r)
 dateDash = later (build . fmt "%F")
 
 -- | As 'dateFmt' @locale@ (e.g. @%m\/%d\/%y@).
-dateSlashL :: FormatTime a => Format a
+dateSlashL :: FormatTime a => Format r (a -> r)
 dateSlashL = later (build . fmt "%x")
 
 -- | Year.
-year :: FormatTime a => Format a
+year :: FormatTime a => Format r (a -> r)
 year = later (build . fmt "%Y")
 
 -- | Last two digits of year, @00@ - @99@.
-yy :: FormatTime a => Format a
+yy :: FormatTime a => Format r (a -> r)
 yy = later (build . fmt "%y")
 
 -- | Century (being the first two digits of the year), @00@ - @99@.
-century :: FormatTime a => Format a
+century :: FormatTime a => Format r (a -> r)
 century = later (build . fmt "%C")
 
 -- | Month name, long form ('fst' from 'months' @locale@), @January@ -
 -- @December@.
-monthName :: FormatTime a => Format a
+monthName :: FormatTime a => Format r (a -> r)
 monthName = later (build . fmt "%B")
 
 -- | @ %H] month name, short form ('snd' from 'months' @locale@),
 -- @Jan@ - @Dec@.
-monthNameShort :: FormatTime a => Format a
+monthNameShort :: FormatTime a => Format r (a -> r)
 monthNameShort = later (build . fmt "%b")
 
 -- | Month of year, leading 0 as needed, @01@ - @12@.
-month :: FormatTime a => Format a
+month :: FormatTime a => Format r (a -> r)
 month = later (build . fmt "%m")
 
 -- | Day of month, leading 0 as needed, @01@ - @31@.
-dayOfMonth :: FormatTime a => Format a
+dayOfMonth :: FormatTime a => Format r (a -> r)
 dayOfMonth = later (build . fmt "%d")
 
 -- | Day of month, @1st@, @2nd@, @25th@, etc.
-dayOfMonthOrd :: FormatTime a => Format a
+dayOfMonthOrd :: FormatTime a => Format r (a -> r)
 dayOfMonthOrd = later (bprint ords . toInt)
   where toInt :: FormatTime a => a -> Int
         toInt = read . formatTime defaultTimeLocale "%d"
 
 -- | Day of month, leading space as needed, @ 1@ - @31@.
-dayOfMonthS :: FormatTime a => Format a
+dayOfMonthS :: FormatTime a => Format r (a -> r)
 dayOfMonthS = later (build . fmt "%e")
 
 -- | Day of year for Ordinal Date format, @001@ - @366@.
-day :: FormatTime a => Format a
+day :: FormatTime a => Format r (a -> r)
 day = later (build . fmt "%j")
 
 -- | Year for Week Date format e.g. @2013@.
-weekYear :: FormatTime a => Format a
+weekYear :: FormatTime a => Format r (a -> r)
 weekYear = later (build . fmt "%G")
 
 -- | Last two digits of year for Week Date format, @00@ - @99@.
-weekYY :: FormatTime a => Format a
+weekYY :: FormatTime a => Format r (a -> r)
 weekYY = later (build . fmt "%g")
 
 -- | Century (first two digits of year) for Week Date format, @00@ -
 -- @99@.
-weekCentury :: FormatTime a => Format a
+weekCentury :: FormatTime a => Format r (a -> r)
 weekCentury = later (build . fmt "%f")
 
 -- | Week for Week Date format, @01@ - @53@.
-week :: FormatTime a => Format a
+week :: FormatTime a => Format r (a -> r)
 week = later (build . fmt "%V")
 
 -- | Day for Week Date format, @1@ - @7@.
-dayOfWeek :: FormatTime a => Format a
+dayOfWeek :: FormatTime a => Format r (a -> r)
 dayOfWeek = later (build . fmt "%u")
 
 -- | Day of week, short form ('snd' from 'wDays' @locale@), @Sun@ -
 -- @Sat@.
-dayNameShort :: FormatTime a => Format a
+dayNameShort :: FormatTime a => Format r (a -> r)
 dayNameShort = later (build . fmt "%a")
 
 -- | Day of week, long form ('fst' from 'wDays' @locale@), @Sunday@ -
 -- @Saturday@.
-dayName :: FormatTime a => Format a
+dayName :: FormatTime a => Format r (a -> r)
 dayName = later (build . fmt "%A")
 
 -- | Week number of year, where weeks start on Sunday (as
 -- 'sundayStartWeek'), @00@ - @53@.
-weekFromZero :: FormatTime a => Format a
+weekFromZero :: FormatTime a => Format r (a -> r)
 weekFromZero = later (build . fmt "%U")
 
 -- | Day of week number, @0@ (= Sunday) - @6@ (= Saturday).
-dayOfWeekFromZero :: FormatTime a => Format a
+dayOfWeekFromZero :: FormatTime a => Format r (a -> r)
 dayOfWeekFromZero = later (build . fmt "%w")
 
 -- | Week number of year, where weeks start on Monday (as
 -- 'mondayStartWeek'), @00@ - @53@.
-weekOfYearMon :: FormatTime a => Format a
+weekOfYearMon :: FormatTime a => Format r (a -> r)
 weekOfYearMon = later (build . fmt "%W")
 
 -- * Time spans, diffs, 'NominalDiffTime', 'DiffTime', etc.
@@ -212,7 +212,7 @@
 -- 'DiffTime'.
 diff :: (RealFrac n)
      => Bool     -- ^ Display 'in/ago'?
-     -> Format n -- ^ Example: '3 seconds ago', 'in three days'.
+     -> Format r (n -> r) -- ^ Example: '3 seconds ago', 'in three days'.)
 diff fix =
   later diffed
   where
@@ -252,35 +252,35 @@
 -- | Display the absolute value time span in years.
 years :: (RealFrac n)
       => Int -- ^ Decimal places.
-      -> Format n
+      -> Format r (n -> r)
 years n = later (bprint (fixed n) . abs . count)
   where count n = n / 365 / 24 / 60 / 60
 
 -- | Display the absolute value time span in days.
 days :: (RealFrac n)
       => Int -- ^ Decimal places.
-      -> Format n
+      -> Format r (n -> r)
 days n = later (bprint (fixed n) . abs . count)
   where count n = n / 24 / 60 / 60
 
 -- | Display the absolute value time span in hours.
 hours :: (RealFrac n)
       => Int -- ^ Decimal places.
-      -> Format n
+      -> Format r (n -> r)
 hours n = later (bprint (fixed n) . abs . count)
   where count n = n / 60 / 60
 
 -- | Display the absolute value time span in minutes.
 minutes :: (RealFrac n)
       => Int -- ^ Decimal places.
-      -> Format n
+      -> Format r (n -> r)
 minutes n = later (bprint (fixed n) . abs . count)
   where count n = n / 60
 
 -- | Display the absolute value time span in seconds.
 seconds :: (RealFrac n)
       => Int -- ^ Decimal places.
-      -> Format n
+      -> Format r (n -> r)
 seconds n = later (bprint (fixed n) . abs . count)
   where count n = n