h$|      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                   (c) 2011 MailRank, Inc. BSD-stylebos@serpentine.com experimentalGHCNone4 formatting%Unsafe conversion for decimal digits. formatting The normal 4 function with right associativity instead of left.4 (c) 2011 MailRank, Inc. BSD-stylebos@serpentine.com experimentalGHCNone formattingRender a value using its  instance. formatting'Render an integral type in hexadecimal.(c) 2011 MailRank, Inc. BSD-stylebos@serpentine.com experimentalGHCNone > formatting-The class of types that can be rendered to a . (c) 2011 MailRank, Inc. BSD-stylebos@serpentine.com experimentalGHCNone / formatting4Pad the left hand side of a string until it reaches k7 characters wide, if necessary filling with character c.0 formatting5Pad the right hand side of a string until it reaches k7 characters wide, if necessary filling with character c.1 formattingRender a floating point number using normal notation, with the given number of decimal places.2 formattingRender a floating point number using the smallest number of digits that correctly represent it.3 formattingRender an integer using hexadecimal notation. (No leading "0x" is added.)1 formatting0Number of digits of precision after the decimal./0123 Safe-Inferred'(>4 formattingA formatter. When you construct formatters the first type parameter, r8, will remain polymorphic. The second type parameter, a, will change to reflect the types of the data that will be formatted. For example, in myFormat :: Format r (Text -> Int -> r) myFormat = "Person's name is " % text % ", age is " % hex the first type parameter remains polymorphic, and the second type parameter is Text -> Int -> r%, which indicates that it formats a  and an .When you run the 4, for example with =, you provide the arguments and they will be formatted into a string. > format ("Person's name is " % text % ", age is " % hex) "Dave" 54 "Person's name is Dave, age is 36" 7 formattingConcatenate two formatters.formatter1 % formatter2, is a formatter that accepts arguments for  formatter1 and  formatter2- and concatenates their results. For example format1 :: Format r (Text -> r) format1 = "Person's name is " % text  %format2 :: Format r r format2 = ", "  9format3 :: Format r (Int -> r) format3 = "age is " % hex  myFormat :: Format r (Text -> Int -> r) myFormat = format1 % format2 % format3 !Notice how the argument types of format1 and format3 are gathered into the type of myFormat./(This is actually the composition operator for 4s  instance, but that is (at present) inconvenient to use with regular Prelude2. So this function is provided as a convenience.)8 formattingFunction compose two formatters. Will feed the result of one formatter into another.9 formatting.Don't format any data, just output a constant .: formatting'Monadic indexed bind for holey monoids.; formatting2Functorial map over a formatter's input. Example: %format (mapf (drop 1) string) "hello"< formattingFormat a value of type a using a function of type a -> . For example, later (f :: Int -> Builder) produces Format r (Int -> r).= formatting$Run the formatter and return a lazy  value.> formatting&Run the formatter and return a strict  value.? formattingRun the formatter and return a  value.@ formattingRun the formatter and return a  value.This is a newer synonym for ?), following the naming convention set by = and >.A formatting3Run the formatter and print out the text to stdout.B formattingRun the formatter and print out the text to stdout, followed by a newline.C formatting4Run the formatter and put the output onto the given .D formattingRun the formatter and put the output and a newline onto the given .E formatting2Run the formatter and return a list of characters.F formatting"The same as (%). At present using  has an import overhead, but one day it might be imported as standard.G formattingUseful instance for writing format string. With this you can write Foo instead of  now "Foo!".H formattingUseful instance for applying two formatters to the same input argument. For example:  format (year <> "/" % month) now will yield  "2015/01".J formatting,This can be used almost like contramap, e.g: formatter :: Format r (b -> r) formatter = _ adapter :: a -> b adapter = _ adapted :: Format r (a -> r) adapted = fmap (. adapter) formatter 456789:;<=>?@ABCDE456789:;<=>?@ABCDE79 88*(c) 2013 Chris Done, 2013 Shachaf Ben-KikiBSD3alex@farfromthere.net experimentalGHCNone $ K formattingOutput a lazy text.L formattingOutput a strict text.M formattingOutput a string.N formatting%Output a showable value (instance of ) by turning it into :format ("Value number " % shown % " is " % shown % ".") 42 False"Value number 42 is False."O formattingOutput a character.P formattingBuild a builder.Q formattingLike  but for formatters.R formatting#Build anything that implements the  Buildable class.S formatting/Render an integral e.g. 123 -> "123", 0 -> "0".T formattingRender some floating point with the usual notation, e.g. 123.32 => "123.32"U formattingRender a floating point number using normal notation, with the given number of decimal places.V formattingRender a floating point number using the smallest number of digits that correctly represent it. Note that in the case of whole numbers it will still add one decimal place, e.g. "1.0".W formattingRender a scientific number.X formatting(Render a scientific number with options.Y formatting,Shows the Int value of Enum instances using .4format ("Got: " % char % " (" % asInt % ")") 'a' 'a' "Got: a (97)"Z formattingPad the left hand side of a string until it reaches k characters wide, if necessary filling with character c.[ formattingPad the right hand side of a string until it reaches k characters wide, if necessary filling with character c.\ formattingPad the left & right hand side of a string until it reaches k characters wide, if necessary filling with character c.] formatting(Group integral numbers, e.g. groupInt 2  on 123456 -> "12.34.56".^ formatting0Fit in the given length, truncating on the left._ formatting1Fit in the given length, truncating on the right.` formatting2Add commas to an integral, e.g 12000 -> "12,000".a formatting6Add a suffix to an integral, e.g. 1st, 2nd, 3rd, 21st.b formatting&English plural suffix for an integral. For example:set -XOverloadedStringsformatPeople = format (int % " " <> plural "person" "people" % ".") :: Int -> Data.Text.Lazy.TextformatPeople 1 "1 person."formatPeople 3 "3 people."c formattingRender an integral at base n.d formattingRender an integer using binary notation. (No leading 0b is added.) Defined as bin = c 2.e formattingRender an integer using octal notation. (No leading 0o is added.) Defined as oct = c 8.f formattingRender an integer using hexadecimal notation. (No leading 0x is added.) Has a specialized implementation.g formatting:Render an integer using binary notation with a leading 0b. See also   for fixed-width formatting.h formatting9Render an integer using octal notation with a leading 0o. See also  for fixed-width formatting.i formatting?Render an integer using hexadecimal notation with a leading 0x. See also  for fixed-width formatting.j formattingRenders a given byte count using an appropiate decimal binary suffix:format (bytes shortest) 1024"1KB",format (bytes (fixed 2 % " ")) (1024*1024*5) "5.00 MB"j formattingformatter for the decimal part!KLMNOPQRSTUVWXYZ[\]^_`abcdefghij!KLMNOPQSTUWXV]`abYZ[\^_cdefghijRFormatting combinators for building new formatters, with some useful pre-defined formatters.(c) 2020 Alex ChapmanBSD3alex@farfromthere.net experimentalGHCNone a=k formattingRender a Maybe value either as a default (if Nothing) or using the given formatter:&format (maybed "Goodbye" text) Nothing "Goodbye"-format (maybed "Goodbye" text) (Just "Hello")"Hello"l formattingRender the value in a Maybe using the given formatter, or produce an empty string:format (optioned text) Nothing""%format (optioned text) (Just "Hello")"Hello"m formattingRender the value in an Either:)format (eithered text int) (Left "Error!""Error!"%format (eithered text int) (Right 69)"69"n formattingRender the value in a Left with the given formatter, rendering a Right as an empty string:#format (lefted text) (Left "bingo")"bingo"format (lefted text) (Right 16)""o formattingRender the value in a Right with the given formatter, rendering a Left as an empty string:format (righted text) (Left 16)""%format (righted text) (Right "bingo")"bingo"p formatting5Format each value in a list and concatenate them all:2format (concatenated text) ["one", "two", "three"] "onetwothree")format (took 15 (concatenated bin)) [1..]3"1101110010111011110001001101010111100110111101111"q formattingUse the given text-joining function to join together the individually rendered items of a list.;format (joinedWith (mconcat . reverse) int) [123, 456, 789] "789456123"r formattingFormat each value in a list and place the given string between each:*fprintLn (intercalated "||" int) [1, 2, 3]1||2||3s formatting3Format each value in a list with spaces in between:format (unworded int) [1, 2, 3]"1 2 3"t formatting:Format each value in a list, placing each on its own line: fprint (unlined char) ['a'..'c']abcu formattingSeparate the formatted items of the Foldable (e.g. list) with spaces:format (spaced int) [1, 2, 3]"1 2 3")Note that this behaviour is identical to s1, it's just a different way of thinking about it.v formattingSeparate the formatted items of the Foldable (e.g. list) with commas:?format (commaSep stext) ["one", "two", "three", "four", "five"]"one,two,three,four,five"$format (took 5 (commaSep int)) [1..] "1,2,3,4,5"w formattingSeparate the formatted items of the Foldable (e.g. list) with commas and spaces:*format (took 3 (commaSpaceSep ords)) [1..]"1st, 2nd, 3rd"x formattingAdd square brackets around the Foldable (e.g. a list), and separate each formatted item with a comma and space.+format (list stext) ["one", "two", "three"]"[one, two, three]"+format (list shown) ["one", "two", "three"]"[\"one\", \"two\", \"three\"]"y formattingLike x7, but also put double quotes around each rendered item:.fprintLn (qlist stext) ["one", "two", "three"]["one", "two", "three"]z formatting3Take only the first n items from the list of items. format (took 7 (list bin)) [1..]!"[1, 10, 11, 100, 101, 110, 111]" format (list bin) (take 7 [1..])!"[1, 10, 11, 100, 101, 110, 111]"{ formatting.Drop the first n items from the list of items.#format (dropped 3 (list int) [1..6] "[4, 5, 6]"| formattingUtility for taking a text-splitting function and turning it into a formatting combinator.6format (splatWith (TL.chunksOf 3) list int) 1234567890"[123, 456, 789, 0]"} formattingSplit the formatted item in places the given predicated matches, and use the given list combinator to render the resultant list of strings (this function was sent to us from a parallel universe in which splat is the past participle of split, e.g. "whoops, I splat my pants").format (splat Data.Char.isSpace commaSpaceSep stext) "This\t is\n\t\t poorly formatted "/"This, , , is, , , , , poorly, formatted, , , "~ formattingSplit the formatted item at instances of the given string, and use the given list combinator to render the resultant list of strings.1fprint (splatOn "," unlined text) "one,two,three"onetwothree7fprint (splatOn "," indentedLines text) "one,two,three" one two three formattingSplit the formatted item into words and use the given list combinator to render the resultant list of strings.,format (worded list text) "one two three ""[one, two, three]" formattingSplit the formatted item into lines and use the given list combinator to render the resultant list of strings.fprintLn (lined qlist text) "one two three\n\nfour five six\nseven eight nine\n\n">["one two three", "", "four five six", "seven eight nine", ""] formatting3Alter the formatted string with the given function.6format (alteredWith Data.Text.Lazy.reverse int) 123456"654321" formattingFilter the formatted string to contain only characters which pass the given predicate:?format (charsKeptIf Data.Char.isUpper text) "Data.Char.isUpper""DCU" formattingFilter the formatted string to not contain characters which pass the given predicate:format (charsRemovedIf Data.Char.isUpper text) "Data.Char.isUpper""ata.har.ispper" formattingTake a formatter and replace the given needle with the given replacement in its output.format (replaced "Bruce" "" stext) "Bruce replied that Bruce's name was, in fact, ''."" replied that 's name was, in fact, ''." formattingConvert any letters in the output of the given formatter to upper-case.=format (uppercased text) "I'm not shouting, you're shouting."$"I'M NOT SHOUTING, YOU'RE SHOUTING." formattingConvert any letters in the output of the given formatter to lower-case.,format (lowercased text) "Cd SrC/; Rm -Rf *""cd src/; rm -rf *" formattingConvert the formatted string to title case, or something like it:.format (titlecased string) "the life of brian""The Life Of Brian" formattingTruncate the formatted string at the end so that it is no more than the given number of characters in length, placing an ellipsis at the end such that it does not exceed this length.!format (truncated 5 text) "hello""hello""format (truncated 5 text) "hellos""he..." formattingTruncate the formatted string at the start so that it is no more than the given number of characters in length, placing an ellipsis at the start such that it does not exceed this length."format (rtruncated 5 text) "hello""hello"#format (rtruncated 5 text) "hellos""...os" formattingTruncate the formatted string in the center, leaving the given number of characters at the start and end, and placing an ellipsis in between. The length will be no longer than `start + end + 3` characters long.format (ctruncated 15 4 text) "The quick brown fox jumps over the lazy dog.""The quick brown...dog."3format (ctruncated 15 4 text) "The quick brown fox""The quick brown fox" formattingPad the formatted string on the left with the given character to give it the given minimum width:format (lpadded 7 ' ' int) 1 " 1"$format (lpadded 7 ' ' int) 123456789 "123456789" formattingPad the formatted string on the right with the given character to give it the given minimum width:format (rpadded 7 ' ' int) 1 "1 " formattingPad the formatted string on the left and right with the given character to center it, giving it the given minimum width:format (cpadded 7 ' ' int) 1 " 1 " formattingFormat the item with a fixed width, padding with the given character on the left to extend, adding an ellipsis on the right to shorten:format (lfixed 10 ' ' int) 123 "123 "%format (lfixed 10 ' ' int) 1234567890 "1234567890"*format (lfixed 10 ' ' int) 123456789012345 "1234567..." formattingFormat the item with a fixed width, padding with the given character on the right to extend, adding an ellipsis on the right to shorten:format (rfixed 10 ' ' int) 123 " 123"%format (rfixed 10 ' ' int) 1234567890 "1234567890"*format (rfixed 10 ' ' int) 123456789012345 "...9012345" formattingFormat the item with a fixed width, padding with the given character on either side to extend, adding an ellipsis in the center to shorten.0The total length will be `l + r + 3` characters.format (cfixed 4 3 ' ' int) 123 " 123 "&format (cfixed 4 3 ' ' int) 1234567890 "1234567890"+format (cfixed 4 3 ' ' int) 123456789012345 "1234...345" formatting+Add the given prefix to the formatted item:>format ("The answer is: " % prefixed "wait for it... " int) 42""The answer is: wait for it... 42";fprint (unlined (indented 4 (prefixed "- " int))) [1, 2, 3] - 1 - 2 - 3 formatting+Add the given suffix to the formatted item. formatting1Surround the output string with the given string:'format (surrounded "***" string) "glue" "***glue***" formatting1Enclose the output string with the given strings:5format (enclosed "" text) "an html comment""" formatting,Add single quotes around the formatted item:let obj = Just Nothing in format ("The object is: " % squoted shown % ".") obj "The object is: 'Just Nothing'." formatting,Add double quotes around the formatted item:fprintLn ("He said it was based on " % dquoted stext % ".") "science""He said it was based on "science". formatting*Add parentheses around the formatted item:?format ("We found " % parenthesised int % " discrepancies.") 17"We found (17) discrepancies."2fprintLn (took 5 (list (parenthesised int))) [1..][(1), (2), (3), (4), (5)] formatting.Add square brackets around the formatted item:format (squared int) 7"[7]" formatting-Add curly brackets around the formatted item:*format ("\\begin" % braced text) "section""\\begin{section}" formatting-Add angle brackets around the formatted item:format (angled int) 7"<7>"format (list (angled text)) ["html", "head", "title", "body", "div", "span"]2"[, , , <body>, <div>, <span>]"� formatting(Add backticks around the formatted item:�format ("Be sure to run " % backticked builder % " as root.") ":(){:|:&};:"'"Be sure to run `:(){:|:&};:` as root."� formatting�Insert the given number of spaces at the start of the rendered text:format (indented 4 int) 7" 7"�Note that this only indents the first line of a multi-line string. To indent all lines see �.� formatting�Format a list of items, placing one per line, indented by the given number of spaces.�fprintLn ("The lucky numbers are:\n" % indentedLines 4 int) [7, 13, 1, 42]The lucky numbers are: 7 13 1 42� formatting�Indent each line of the formatted string by the given number of spaces:,fprint (reindented 2 text) "one\ntwo\nthree" one two three� formatting�Take a fractional number and round it before formatting it as the given Format:format (roundedTo int) 6.66"7"5format (list (roundedTo int)) [10.66, 6.66, 1.0, 3.4]"[11, 7, 1, 3]"Note: the type variable f� will almost always be 'Format r', so the type of this function can be thought of as: �roundedTo :: (Integral i, RealFrac d) => Format r (i -> r) -> Format r (d -> r) � formatting�Take a fractional number and truncate it before formatting it as the given Format:format (truncatedTo int) 6.66"6"7format (list (truncatedTo int)) [10.66, 6.66, 1.0, 3.4]"[10, 6, 1, 3]"Note: the type variable f� will almost always be 'Format r', so the type of this function can be thought of as: �truncatedTo :: (Integral i, RealFrac d) => Format r (i -> r) -> Format r (d -> r) � formatting�Take a fractional number and ceiling it before formatting it as the given Format:format (ceilingedTo int) 6.66"7"7format (list (ceilingedTo int)) [10.66, 6.66, 1.0, 3.4]"[11, 7, 1, 4]"Note: the type variable f� will almost always be 'Format r', so the type of this function can be thought of as: �ceilingedTo :: (Integral i, RealFrac d) => Format r (i -> r) -> Format r (d -> r) � formatting�Take a fractional number and floor it before formatting it as the given Format:format (flooredTo int) 6.66"6"5format (list (flooredTo int)) [10.66, 6.66, 1.0, 3.4]"[10, 6, 1, 3]"Note: the type variable f� will almost always be 'Format r', so the type of this function can be thought of as: �flooredTo :: (Integral i, RealFrac d) => Format r (i -> r) -> Format r (d -> r) � formatting�Use the given lens to view an item, formatting it with the given formatter.)You can think of this as having the type: � :: Lens'/ s a -> Format r (a -> r) -> Format r (s -> r) #format (viewed _1 int) (1, "hello")"1"This is useful when combined with the Monoid instance for Format, because it allows us to give a data structure as an argument only once, and deconstruct it with the formatters: �data Person = Person { _personName :: Text , _personAge :: Int } makeLenses ''Person me :: Person me = Person Alex 38 format ("The person's name is " % squoted (viewed personName text) % ", and their age is " <> viewed personAge int) me "The person's name is Alex, and their age is 38" � formatting�Access an element of the structure and format it with the given formatter.&format (accessed fst int) (1, "hello")"1"Repeating the example from �:format ("The person's name is " % squoted (accessed _personName text) % ", and their age is " <> accessed _personAge int) me "The person's name is Alex, and their age is 38"� formatting�Render an integer using binary notation with a leading 0b, padding with zeroes to the given width:format (binPrefix 16) 4097"0b0001000000000001"� formatting�Render an integer using octal notation with a leading 0o, padding with zeroes to the given width:format (octPrefix 16) 4097"0o0000000000010001"� formatting�Render an integer using octal notation with a leading 0x, padding with zeroes to the given width:format (hexPrefix 16) 4097"0x0000000000001001"k�� formatting*The value to use when the input is Nothing� formatting+The formatter to use on the value in a Justm�� formatting)The formatter to use on a value in a Left� formatting*The formatter to use on a value in a Right|�� formattingThe text splitter� formatting#A list-formatting combinator, e.g. �s, �x, �p, etc.� formatting5The base formatter, whose rendered text will be split}�� formatting-Whether to split the string at this character� formatting#A list-formatting combinator, e.g. �s, �x, �p, etc.� formatting5The base formatter, whose rendered text will be split~�� formattingThe text to split on� formatting#A list-formatting combinator, e.g. �s, �x, �p, etc.� formatting5The base formatter, whose rendered text will be split�� formatting#A list-formatting combinator, e.g. �s, �x, �p, etc.� formatting5The base formatter, whose rendered text will be split�� formatting#A list-formatting combinator, e.g. �s, �x, �p, etc.� formatting5The base formatter, whose rendered text will be split=klmnopqrstuvwxyz{|}~=klmnopqrstuvwxyz{}|~������*(c) 2013 Chris Done, 2013 Shachaf Ben-KikiBSD3alex@farfromthere.net experimentalGHCNone����b���46789;<=>?@ABCDEKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~4789<;6=>?@ABCDE�����������None ��d� formattingSimple hello, world!� formattingPrinting strings.� formattingPrinting texts.� formattingPrinting builders.� formattingPrinting integers.� formattingPrinting floating points.� formatting$Printing integrals in hex (base-16).� formattingPadding.������������None ��eP� formattingSame as  durationNS but works on � from the clock package.������������None���eq���/0123 /0312�������*(c) 2013 Chris Done, 2013 Shachaf Ben-KikiBSD3chrisdone@gmail.com experimentalGHCNone����j> � formattingOutput a lazy text.� formatting/Render an integral e.g. 123 -> "123", 0 -> "0".� formatting�Render an integer using binary notation. (No leading 0b is added.)� formatting�Render an integer using octal notation. (No leading 0o is added.)� formatting�Render an integer using hexadecimal notation. (No leading 0x is added.)� formattingOutput a strict text.� formattingOutput a string.� formatting%Output a showable value (instance of �) by turning it into �.� formattingOutput a character.� formatting�Render a floating point number using normal notation, with the given number of decimal places.� formatting�Render a floating point number using the smallest number of digits that correctly represent it.� formatting4Pad the left hand side of a string until it reaches k7 characters wide, if necessary filling with character ch.� formatting5Pad the right hand side of a string until it reaches k7 characters wide, if necessary filling with character ch.�  ���� �������None ����{C2� formattingTimezone offset on the format -HHMM.� formattingTimezone name.� formattingAs  dateTimeFmt locale (e.g. %a %b %e %H:%M:%S %Z %Y).� formattingSame as %H:%M.� formattingSame as %H:%M:%S.� formattingAs timeFmt locale (e.g. %H:%M:%S).� formattingAs  time12Fmt locale (e.g.  %I:%M:%S %p).� formattingDay half from (amPm locale), converted to lowercase, am, pm.� formattingDay half from (amPm locale), AM, PM.� formatting$Hour, 24-hour, leading 0 as needed, 00 - 23.� formatting$Hour, 12-hour, leading 0 as needed, 01 - 12.� formatting(Hour, 24-hour, leading space as needed,  0 - 23.� formatting(Hour, 12-hour, leading space as needed,  1 - 12.� formattingMinute, 00 - 59.� formattingSecond, without decimal part, 00 - 60.� formatting&Picosecond, including trailing zeros,  000000000000 -  999999999999.� formattingDecimal point and up to 12 second decimals, without trailing zeros. For a whole number of seconds, this produces the empty string.� formattingSame as %m/%d/%y.� formattingSame as %Y-%m-%d.� formattingAs dateFmt locale (e.g. %m/%d/%y).� formattingYear.� formattingLast two digits of year, 00 - 99.� formatting2Century (being the first two digits of the year), 00 - 99.� formattingMonth name, long form (� from months locale), January - December.� formatting %H] month name, short form (� from months locale), Jan - Dec@.� formatting$Month of year, leading 0 as needed, 01 - 12.� formatting#Day of month, leading 0 as needed, 01 - 31.� formattingDay of month, 1st, 2nd, 25th, etc.� formatting'Day of month, leading space as needed,  1 - 31.� formatting%Day of year for Ordinal Date format, 001 - 366.� formattingYear for Week Date format e.g. 2013.� formatting.Last two digits of year for Week Date format, 00 - 99.� formatting9Century (first two digits of year) for Week Date format, 00 - 99.� formattingWeek for Week Date format, 01 - 53.� formattingDay for Week Date format, 1 - 7.� formattingDay of week, short form (� from wDays locale), Sun - Sat.� formattingDay of week, long form (� from wDays locale), Sunday - Saturday.� formatting6Week number of year, where weeks start on Sunday (as sundayStartWeek), 00 - 53.� formattingDay of week number, 0 (= Sunday) - 6 (= Saturday).� formatting6Week number of year, where weeks start on Monday (as mondayStartWeek), 00 - 53.� formatting�Display a time span as one time relative to another. Input is assumed to be seconds. Typical inputs are NominalDiffTime and DiffTime.� formatting.Display the absolute value time span in years.� formatting-Display the absolute value time span in days.� formatting.Display the absolute value time span in hours.� formatting0Display the absolute value time span in minutes.� formatting0Display the absolute value time span in seconds.� formatting+Display seconds in the following pattern:  00:00:00:00$, which ranges from days to seconds.� formatting Variation of ��, which lets you explicitly specify how to render each component.� formatting0Formatter call. Probably don't want to use this.� formatting*Helper for creating custom time formatters�� formattingDisplay 'in/ago'?� formatting+Example: '3 seconds ago', 'in three days'.)�� formattingDecimal places.�� formattingDecimal places.�� formattingDecimal places.�� formattingDecimal places.�� formattingDecimal places.33���� ��� ��� �� �� ��� �� �������������������������������� ���!���"���#���$���%���&���'���(���)���*���+���,���-���.���/���0���1���2���3���4���5���6���7���8���9���:���;���<���=�� �>�� �?�� �@�� �A�� �B��C��C���D���E���F���G���H���I���J���K���L���M���N���O���P���Q���R���S���T���U���V���W���X���Y���Z���[������\���]���^������_���`���@���A���a���b���c���>���?���d���e���f���g���h���i���j���k���l���m���B���n���o���p���q���r���s���t���u���v���w���x���y���z���{���|���}���~������������������������������������������������������������������������������������������������������������������������������������������ �������������������������������������������������������������������������� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��k��k����k��k�k��k��k�������k��k�'formatting-7.1.2-H2z7UX4j5qqAuwdGVpfzN0Formatting.Internal.RawFormatting.BuildableFormatting.InternalFormatting.FormattersFormatting.CombinatorsFormatting.ExamplesFormatting.ClockFormatting.ShortFormattersFormatting.TimeData.Text.Format.FunctionsData.Text.Format.TypesData.Text.Format binPrefix octPrefix hexPrefix Formattingi2d<>ShownshownHex Buildablebuild $fBuildable[]$fBuildableBool$fBuildablePtr$fBuildableWordPtr$fBuildableIntPtr$fBuildableZonedTime$fBuildableLocalTime$fBuildableTimeZone$fBuildableTimeOfDay$fBuildableMaybe$fBuildableShown$fBuildableDay$fBuildableUniversalTime$fBuildableUTCTime$fBuildableNominalDiffTime$fBuildableDiffTime$fBuildableDouble$fBuildableFloat$fBuildableRatio$fBuildableWord64$fBuildableWord$fBuildableWord32$fBuildableWord16$fBuildableWord8$fBuildableFixed$fBuildableInteger$fBuildableInt64$fBuildableInt$fBuildableInt32$fBuildableInt16$fBuildableInt8$fBuildableHex$fBuildable[]0$fBuildableChar$fBuildableText$fBuildableText0$fBuildableVoid$fBuildableBuilderleftrightfixedshortesthexFormat runFormat%%.nowbindmapflaterformatsformatbprintbformatfprintfprintLnhprinthprintLnformatToString$fCategoryTYPEFormat$fIsStringFormat$fMonoidFormat$fSemigroupFormat$fFunctorFormattextstextstringcharbuilderfconstintfloatsciscifmtasIntcentergroupIntfitLeftfitRightcommasordspluralbasebinoct prefixBin prefixOct prefixHexbytesmaybedoptionedeitheredleftedrighted concatenated joinedWith intercalatedunwordedunlinedspacedcommaSep commaSpaceSeplistqlisttookdropped splatWithsplatsplatOnwordedlined alteredWith charsKeptIfcharsRemovedIfreplaced uppercased lowercased titlecased ltruncated rtruncated ctruncatedlpaddedrpaddedcpaddedlfixedrfixedcfixedprefixedsuffixed surroundedenclosedsquoteddquoted parenthesisedsquaredbracedangled backtickedindented indentedLines reindented roundedTo truncatedTo ceilingedTo flooredToviewedaccessedhellostringstextsbuildersintegersfloatshexespadding timeSpecstdboxstsshcfsflrtztzNamedatetimehmhmshmsLhmsPLdayHalfdayHalfUhour24hour12hour24Shour12Sminutesecondpicodecimalsepoch dateSlashdateDash dateSlashLyearyycentury monthNamemonthNameShortmonth dayOfMonth dayOfMonthOrd dayOfMonthSdayweekYearweekYY weekCenturyweek dayOfWeek dayNameShortdayName weekFromZerodayOfWeekFromZero weekOfYearMondiffyearsdayshoursminutessecondsdiffComponentscustomDiffComponentsfmt customTimeFmtGHC.BasemappendGHC.ShowShow text-1.2.4.1Data.Text.Internal.BuilderBuilderData.Text.Internal.LazyTextghc-prim GHC.TypesIntControl.CategoryCategoryData.Text.InternalGHC.IO.Handle.TypesHandleconstGHC.EnumfromEnum. clock-0.8-3vNRSIIFvuh5T6Bf3yeRJC System.ClockTimeSpecData.Text.Lazy.Builder.Int hexadecimaldecimal Data.Tuplefstsnd