.t      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsNone%&9;A more powerful  used for genericFS. Can build functions, tuples, lists, maps, etc., as well as combinations thereof.2Get fields, together with their names if available %Format a tuple (of up to 8 elements):tupleF (1,2,"hi") "(1, 2, hi)"HIf any of the elements takes several lines, an alternate format is used: >>> ,fmt $ tupleF ("test","foo\nbar","more test")& ( test , foo bar , more test ) Convert a bytestring to base64:(base64F ("\0\50\63\80" :: BS.ByteString) "ADI/UA=="CConvert a bytestring to base64url (a variant of base64 which omits / and thus can be used in URLs):+base64UrlF ("\0\50\63\80" :: BS.ByteString) "ADI_UA=="%Format a number or bytestring as hex: hexF 3635"e33"%hexF ("\0\50\63\80" :: BS.ByteString) "00323f50" Convert a  to something else.GAdd a prefix to the first line, and indent all lines but the first one.GThe output will always end with a newline, even when the input doesn't.  !        !None 9:;DQRT*"Concatenate, then convert# and concatenate, then convert$Concatenate, then convert%t and concatenate, then convert*,An old-style formatting function taken from  text-format (see Data.Text.Format ). Unlike  from Data.Text.Format, it can produce u and strict Text$ as well (and print to console too)./To provide substitution arguments, use a tuple:format "{} + {} = {}" (2, 2, 4) "2 + 2 = 4"!You can use arbitrary formatters:@format "0x{} + 0x{} = 0x{}" (hexF 130, hexF 270, hexF (130+270)) "2 + 2 = 4"<To provide just one argument, use a list instead of a tuple:format "Hello {}!" ["world"]"Hello world!"+Like *, but adds a newline.,, converts things to u, Text or .>Most of the time you won't need it, as strings produced with (") and (#) can already be used as u, Text!, etc. However, combinators like / can only produce 2 (for better type inference), and you need to use , on them.Also, , can do printing:fmt "Hello world!\n" Hello world!-Like ,, but appends a newline..Attach a name to anything:<fmt $ nameF "clients" $ blockListF ["Alice", "Bob", "Zalgo"]clients: - Alice - Bob - Zalgo/(A simple comma-separated list formatter.listF ["hello", "world"]"[hello, world]"For multiline output, use 3.0 A version of /C that lets you supply your own building function for list elements.PFor instance, to format a list of lists you'd have to do this (since there's no  instance for lists):listF' listF [[1,2,3],[4,5,6]]"[[1, 2, 3], [4, 5, 6]]"1 A multiline formatter for lists.fmt $ blockListF [1,2,3]- 1- 2- 31It automatically handles multiline list elements: >>> 3fmt $ blockListF ["hello\nworld", "foo\nbar\nquix"]% - hello world - foo bar quix 2 A version of 1C that lets you supply your own building function for list elements.3!A JSON-style formatter for lists.fmt $ jsonListF [1,2,3][ 1, 2, 3]Like 1%, it handles multiline elements well:2fmt $ jsonListF ["hello\nworld", "foo\nbar\nquix"][ hello world, foo bar quix](Note that, unlike 1,, it doesn't add blank lines in such cases.)4 A version of 3C that lets you supply your own building function for list elements.5bA simple JSON-like map formatter; works for Map, HashMap, etc, as well as ordinary lists of pairs.mapF [("a", 1), ("b", 4)]"{a: 1, b: 4}"For multiline output, use 9.6 A version of 5E that lets you supply your own building function for keys and values.7A YAML-like map formatter:Ifmt $ blockMapF [("Odds", blockListF [1,3]), ("Evens", blockListF [2,4])]Odds: - 1 - 3Evens: - 2 - 48 A version of 7E that lets you supply your own building function for keys and values.9"A JSON-like map formatter (unlike 5, always multiline):Ffmt $ jsonMapF [("Odds", jsonListF [1,3]), ("Evens", jsonListF [2,4])] { Odds: [ 1 , 3 ], Evens: [ 2 , 4 ]}: A version of 9E that lets you supply your own building function for keys and values.;=Format a list like a tuple. (This function is used to define  .)<Like  for v, but displays w as  <Nothing> instead of an empty string.:build (Nothing :: Maybe Int)""build (Just 1 :: Maybe Int)"1"<:maybeF (Nothing :: Maybe Int) "<Nothing>"maybeF (Just 1 :: Maybe Int)"1"= Format an x:eitherF (Right 1) "<Right: 1>">Take the first N characters:prefixF 3 "hello""hel"?Take the last N characters:suffixF 3 "hello""llo"@ padLeftF n c pads the string with character c% from the left side until it becomes nR characters wide (and does nothing if the string is already that long, or longer):padLeftF 5 '0' 12"00012"padLeftF 5 '0' 123456"123456"A padRightF n c pads the string with character c& from the right side until it becomes nR characters wide (and does nothing if the string is already that long, or longer):padRightF 5 ' ' "foo""foo "padRightF 5 ' ' "foobar""foobar"B padBothF n c pads the string with character c" from both sides until it becomes nR characters wide (and does nothing if the string is already that long, or longer):padBothF 5 '=' "foo""=foo="padBothF 5 '=' "foobar""foobar"FWhen padding can't be distributed equally, the left side is preferred:padBoth 8 '=' "foo" "===foo=="C"Add an ordinal suffix to a number: ordinalF 15"15th" ordinalF 22"22nd"DBreak digits in a number:commaizeF 15830000 "15,830,000"EFormat a number as octal:listF' octF [7,8,9,10]"[7, 10, 11, 12]"FFormat a number as binary:listF' binF [7,8,9,10]"[111, 1000, 1001, 1010]"G-Format a number in arbitrary base (up to 36): baseF 3 10000 "111201101" baseF 7 10000"41104"baseF 36 10000"7ps"HFormat a floating-point number: floatF 3.1415"3.1415"ZNumbers bigger than 1e21 or smaller than 1e-6 will be displayed using scientific notation:listF' floatF [1e-6,9e-7]"[0.000001, 9e-7]"listF' floatF [9e20,1e21]"[900000000000000000000, 1e21]"IYFormat a floating-point number using scientific notation, with given amount of precision:listF' (exptF 5) [pi,0.1,10]$"[3.14159e0, 1.00000e-1, 1.00000e1]"J>Format a floating-point number with given amount of precision.PFor small numbers, it uses scientific notation for everything smaller than 1e-6:!listF' (precF 3) [1e-5,1e-6,1e-7]""[0.0000100, 0.00000100, 1.00e-7]"hFor large numbers, it uses scientific notation for everything larger than 1eN, where N is the precision:listF' (precF 4) [1e3,5e3,1e4]"[1000, 5000, 1.000e4]"K;Format a floating-point number without scientific notation:listF' (fixedF 5) [pi,0.1,10]"[3.14159, 0.10000, 10.00000]"L+Display something only if the condition is y (empty string otherwise). >>> 9"Hello!" <> whenF showDetails (", details: "#|foobar|#"") Note that it can only take a / (because otherwise it would be unusable with ("-)-formatted strings which can resolve to any  ). Thus, use , if you need just one value: >>> 1"Maybe here's a number: "#|whenF cond (fmt n)|#"" M+Display something only if the condition is z (empty string otherwise).NIndent already formatted text.:fmt $ "This is a list:\n" <> indent 4 (blockListF [1,2,3])This is a list: - 1 - 2 - 3GThe output will always end with a newline, even when the input doesn't.O.Format an arbitrary value without requiring a  instance: <data Foo = Foo { x :: Bool, y :: [Int] } deriving Generic !fmt (genericF (Foo True [1,2,3]))Foo: x: True y: [1, 2, 3])It works for non-record constructors too: -data Bar = Bar Bool [Int] deriving Generic #fmtLn (genericF (Bar True [1,2,3]))<Bar: True, [1, 2, 3]>*Any fields inside the type must either be  or one of the following types: a functiona tuple (up to 8-tuples)list, {, |}, ~, , v, xThe exact format of OZ might change in future versions, so don't rely on it. It's merely a convenience function.R"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs7  "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO7"#$%&')(*+,-N./0123456789: ;<=>?@AB CDEFGHIJKLMOR"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs"1#1$1%1&1'1(1)1      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}}}}}"fmt-0.1.0.0-4tNTUmlpfOV8LQysRpkl2NFmt Fmt.InternalData.Text.Formatformat#text-1.2.2.1-9Yh8rJoh8fO2JMLWffT3QsData.Text.Internal.BuilderBuilder*text-format-0.3.1.1-9pUcux7N0OW6bXsl3OJ5gEData.Text.Buildablebuild BuildableData.Text.Format.Types.InternalFormat Buildable'build' GetFields getFields GBuildablegbuildTupleFtupleFFormatAsBase64base64F base64UrlF FormatAsHexhexF FromBuilder fromBuildergroupIntatBase showSigned' intToDigit'indent'$fFormatAsBase64ByteString$fFormatAsBase64ByteString0$fFormatAsHexa$fFormatAsHexByteString$fFormatAsHexByteString0$fFromBuilderIO$fFromBuilderText$fFromBuilderText0$fFromBuilder[]$fFromBuilderBuilder#||##||||#|##|||##||||##||##||formatLnfmtfmtLnnameFlistFlistF' blockListF blockListF' jsonListF jsonListF'mapFmapF' blockMapF blockMapF'jsonMapF jsonMapF' tupleLikeFmaybeFeitherFprefixFsuffixFpadLeftF padRightFpadBothFordinalF commaizeFoctFbinFbaseFfloatFexptFprecFfixedFwhenFunlessFindentgenericF $fBuildable'a$fBuildable'(->)$fBuildable'Either$fBuildable'Maybe$fBuildable'IntSet$fBuildable'IntMap$fBuildable'Set$fBuildable'Map$fBuildable'Seq$fBuildable'NonEmpty$fBuildable'[]$fBuildable'[]0$fBuildable'(,,,,,,,)$fBuildable'(,,,,,,)$fBuildable'(,,,,,)$fBuildable'(,,,,)$fBuildable'(,,,)$fBuildable'(,,)$fBuildable'(,)$fBuildable'() $fGetFieldsU1 $fGetFieldsM1$fGetFieldsM10$fGetFieldsM11$fGetFields:*:$fGBuildable:+:$fGBuildableK1$fGBuildableM1$fGBuildableM10$fTupleF(,,,,,,,)$fTupleF(,,,,,,)$fTupleF(,,,,,)$fTupleF(,,,,) $fTupleF(,,,) $fTupleF(,,) $fTupleF(,)baseGHC.ShowshowGHC.BaseStringMaybeNothing Data.EitherEitherghc-prim GHC.TypesTrueFalseData.List.NonEmptyNonEmptycontainers-0.5.7.1 Data.SequenceSeq Data.Map.BaseMapData.IntMap.BaseIntMap Data.Set.BaseSetData.IntSet.BaseIntSet