H@O      Safe-Inferred"Class for valid printf arguments. 8The internal type used to wrap and store all arguments. r !"#$%&'()*+,-. /0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw 013P"! #'&%$()*+,-.  /0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwNone "A static checking layer on top of  . It hasn't N been tested much, but static argument checking is always a good idea. To use  it, add  " {-# LANGUAGE TemplateHaskell #-}   import Text.Printf.Mauke.TH !at the top of your code and call $(  "%d %d") x y instead of   "%d %d" x y. -Starting with version 0.6.0 of this library,   's return type is  overloaded: Like the non-TH  it can return either  a x or y a. (It used to return x unconditionally.)  Works like   but always returns a x. In versions before 1 0.6.0 of this library, this function was called printf. z{|}~   z{|}~  Safe-InferredDFormat a variable number of arguments according to a format string, < similar to (s)printf in Perl. The return value is either a x or  y a), in which case the result is printed to . If you use the  y variant, don'3t use the result: Because it has to be of any type a,  this library makes it . EThe format string consists of ordinary characters (everything except  '%'B), which are passed through unchanged, and formatting directives,  which have the following form:    % flag* vector? width?  precision? type (* and ?A mean 0 or more and 0 or 1 of the preceding item, respectively.) Flags:  space& prefix positive numbers with a space +G prefix positive numbers with a plus sign (overrides space if both are  present) - left-justify within the field 0) pad with zeroes on the left, not spaces # prefix binary numbers with 0b/0B, octal numbers with 0o/0O  and hexadecimal numbers with 0x/0X The vector flag v tells ( to format each character in the string L argument according to the current directive, then joins the results with a  separator that defaults to ".". When *v is used, the separator is ( taken from the argument list (use e.g.  "%*v.2x" "" str if you  want no separator). The width is either a decimal integer or *, in which case the width is E taken from the argument list (this argument must be an integer). It J specifies the minimum width for this field. Shorter values are padded on 6 the left with spaces (but this can be changed by the 0 and - flags). If  the width@ taken from the argument list is negative, it behaves as if the  - flag was specified. The  precision consists of a . followed by digits or a * (see the  description of width* above). The effects depend on the format type: K for floating point formats, this specifies the number of digits after the  decimal point H for string formats, this is the maximum number of characters to appear  (longer strings are truncated) H for integer formats, this is the minimum number of digits to appear in , the output; shorter values are zero-padded Types: %* A percent sign. No argument is consumed. cB A character. If the argument is an integer, it is converted with  chr. s A string. d A decimal integer. u An unsigned decimal integer. b A binary integer. B Like b, but using a 0B prefix with #. o An octal integer. O Like o, but using a 0O prefix with #. x A hexadecimal integer. X Like x, but using uppercase letters. e1 A floating point number in scientific notation. E Like e, but using an uppercase E. f4 A floating point number in fixed decimal notation. g A floating point number in %e or %f notation. G Like g, but using an uppercase E. _# A generic format; it behaves like %c, %s, %d or %g , depending  on the argument type. Like 5, except that the result is printed to the specified  .          !"#$%&'()*++,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~zzzprintf-mauke-0.6.0Text.Printf.MaukeText.Printf.Mauke.THText.Printf.Mauke.Internalprintf PrintfArgembedArgAFloatAStrACharAIntToChartoCharFromCharfromCharsprintf HPrintfType PrintfTypehPrintfTypeTanyTBTbTGTETXTOTgTfTeTxToTuTdTsTcTpercentFlagFAltFZeroFPlusFSpaceSpecflagsvectorwidth precisionftype thisModulediepdieashowvprintfch2flagch2typeenoargaunconsarg2intarg2int'arg2str arg2floatparseIntparseVecparsepadWithpadCharint2char dropSuffixapply $fDefaultType $fDefaultSpec $fPrintfArgFd$fPrintfArgCSsize$fPrintfArgCPid$fPrintfArgCOff$fPrintfArgCMode$fPrintfArgCIno$fPrintfArgCUIntMax$fPrintfArgCIntMax$fPrintfArgCUIntPtr$fPrintfArgCIntPtr$fPrintfArgCULLong$fPrintfArgCLLong$fPrintfArgCSigAtomic$fPrintfArgCWchar$fPrintfArgCSize$fPrintfArgCPtrdiff$fPrintfArgCULong$fPrintfArgCLong$fPrintfArgCUInt$fPrintfArgCInt$fPrintfArgCUShort$fPrintfArgCShort$fPrintfArgCUChar$fPrintfArgCSChar$fPrintfArgCChar$fPrintfArgWordPtr$fPrintfArgIntPtr$fPrintfArgWord64$fPrintfArgWord32$fPrintfArgWord16$fPrintfArgWord8$fPrintfArgWord$fPrintfArgInt64$fPrintfArgInt32$fPrintfArgInt16$fPrintfArgInt8$fPrintfArgInt$fPrintfArgInteger$fPrintfArgRatio$fPrintfArgCDouble$fPrintfArgCFloat$fPrintfArgFloat$fPrintfArgDouble$fPrintfArgByteString$fPrintfArgByteString0 $fPrintfArg[]$fPrintfArgChar $fToCharWord8 $fToCharChar$fFromCharCharbaseGHC.BaseStringghc-prim GHC.TypesIO PrintfResultoutputToStringtoStringPTypeXFSCIxprintfgenparamstembed$fPrintfResultIO$fPrintfResult[]$fToStringByteString$fToStringByteString0 $fToString[]GHC.IO.Handle.FDstdoutGHC.Err undefinedGHC.IO.Handle.TypesHandlehcollectcollectundefinedResult$fHPrintfTypeIO$fHPrintfType(->)$fPrintfTypeIO$fPrintfType(->)$fPrintfType[]