!(&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$% (c) Dennis Gosnell, 2016BSD-style (see LICENSE file)cdep.illabout@gmail.com experimentalPOSIXNone 27>SX/P pretty-simple>These options are for colorizing the output of functions like pPrint.For example, if you set  to something like , then the quote character ("() will be output as bright blue in bold.=If you don't want to use a color for one of the options, use 5. pretty-simple#Color to use for quote characters (") around strings. pretty-simpleColor to use for strings. pretty-simple(currently not used) pretty-simpleColor to use for numbers. pretty-simple A list of & colors to use for rainbow parenthesis output. Use '[]' if you don't want rainbow parenthesis. Use just a single item if you want all the rainbow parenthesis to be colored the same. pretty-simple3Default color options for use on a dark background. is .  is  .  is  .  is  .  is defaultColorRainboxParensDarkBg. pretty-simpleDefault color for  for dark backgrounds. This is .  pretty-simpleDefault color for  for dark backgrounds. This is .  pretty-simpleDefault color for ! for dark backgrounds. This is .  pretty-simpleDefault color for ! for dark backgrounds. This is .  pretty-simpleDefault colors for  for dark backgrounds.  pretty-simple4Default color options for use on a light background. is .  is .  is .  is .  is  defaultColorRainboxParensLightBg. pretty-simpleDefault color for ! for light backgrounds. This is . pretty-simpleDefault color for ! for light backgrounds. This is . pretty-simpleDefault color for " for light backgrounds. This is . pretty-simpleDefault color for " for light backgrounds. This is . pretty-simpleDefault colors for  for light backgrounds.3 pretty-simpleChange the intensity to '.4 pretty-simple(" the console color back to normal.5 pretty-simple Empty string.6 pretty-simpleHelper for creating a &/ for an ANSI escape sequence color based on a ) and a *.7 pretty-simpleConvert a list of + to a &.8  !"#$%&'()*+,-./012345678  !"#$%&'()*+,-./01234567(c) Dennis Gosnell, 2016BSD-style (see LICENSE file)cdep.illabout@gmail.com experimentalPOSIXNone 27>SX7A pretty-simpleWe could store this as a ,, say, instead of a -}. However, we will never need to use its value for anything. Indeed, the only thing we will be doing with it is turning it backk into a string at some stage, so we might as well cut out the middle man and store it directly like this. ;A@?>=<BCDE CDE;A@?>=<B(c) Dennis Gosnell, 2016BSD-style (see LICENSE file)cdep.illabout@gmail.com experimentalPOSIXNone 27>SXWN pretty-simpleN and OK are convenient to use in GHCi when playing around with how parsing works.O pretty-simpleSee N.R pretty-simpleParse multiple expressions.parseExprs "Just 'a'" ([Other "Just ",CharLit "a"],"")#Handle escaped characters correctly'parseExprs $ "Foo \"hello \\\"world!\""0([Other "Foo ",StringLit "hello \\\"world!"],"")parseExprs $ "'\\''"([CharLit "\\'"],"")T pretty-simple4Parse string literals until a trailing double quote.parseStringLit "foobar\" baz"("foobar"," baz")Keep literal back slashes:'parseStringLit "foobar\\\" baz\" after"("foobar\\\" baz"," after")U pretty-simple7Parse character literals until a trailing single quote.parseCharLit "a' foobar"("a"," foobar")Keep literal back slashes:parseCharLit "\\'' hello"("\\'"," hello")V pretty-simple Parses integers and reals, like 123 and 45.67.3To be more precise, any numbers matching the regex  \d+(\.\d+)?% should get parsed by this function.&parseNumberLit '3' "456hello world []"("3456","hello world []")%parseNumberLit '0' ".12399880 foobar"("0.12399880"," foobar")W pretty-simpleThis function consumes input, stopping only when it hits a special character or a digit. However, if the digit is in the middle of a Haskell-style identifier (e.g. foo123), then keep going anyway.'This is almost the same as the function eparseOtherSimple = span $ \c -> notElem c ("{[()]}\"," :: String) && not (isDigit c) && (c /= '\'')except WK ignores digits and single quotes that appear in Haskell-like identifiers.parseOther "hello world []"("hello world ","[]")parseOther "hello234 world"("hello234 world","")parseOther "hello 234 world"("hello ","234 world")parseOther "hello{[ 234 world"("hello","{[ 234 world")parseOther "H3110 World"("H3110 World","")&parseOther "Node' (Leaf' 1) (Leaf' 2)" ("Node' ","(Leaf' 1) (Leaf' 2)")parseOther "I'm One"("I'm One","")parseOther "I'm 2" ("I'm ","2") NOPQRSTUVW NOPQRSTUVW(c) Dennis Gosnell, 2016BSD-style (see LICENSE file)cdep.illabout@gmail.com experimentalPOSIXNone/27>HMSVXphX pretty-simpleAn \ token together with a j. Basically, each \ keeps track of its own j.\ pretty-simpleCThese are the output tokens that we will be printing to the screen.] pretty-simpleThis represents the } character.^ pretty-simpleThis represents the ] character._ pretty-simpleThis represents the ) character.` pretty-simpleThis represents the , character.a pretty-simpleThis represents an indentation.b pretty-simpleThis represents the \n character.c pretty-simpleThis represents the { character.d pretty-simpleThis represents the [ character.e pretty-simpleThis represents the ( character.f pretty-simple[This represents some collection of characters that don't fit into any of the other tokens.g pretty-simple1This represents a string literal. For instance, "foobar".h pretty-simple.This represents a char literal. For example, x or '\b'i pretty-simple1This represents a numeric literal. For example, 12345 or 3.14159.j pretty-simple3Datatype representing how much something is nested.For example, a j of 0 would mean an X8 token is at the very highest level, not in any braces.A j of 1 would mean that an X! token is in one single pair of { and }, or [ and ], or @ and @@.A j of 2 would mean that an X' token is two levels of brackets, etc.m pretty-simple. (and /W) should generally only be used in tests and debugging. There is no way to represent a, i and g.XY[Z\ihgfedcba`_^]jkljkl\ihgfedcba`_^]XY[Z(c) Dennis Gosnell, 2016BSD-style (see LICENSE file)cdep.illabout@gmail.com experimentalPOSIXNone 27>HMSVX pretty-simpleNewtype around 04 to represent a line number. After a newline, the  will increase by 1. pretty-simpleSmart-constructor for . pretty-simple%Print a surrounding expression (like [] or {} or ()).If the C> expressions are empty, just print the start and end markers.6testInit $ putSurroundExpr "[" "]" (CommaSeparated [])[Output {outputNestLevel = NestLevel {unNestLevel = 0}, outputOutputType = OutputOpenBracket},Output {outputNestLevel = NestLevel {unNestLevel = 0}, outputOutputType = OutputCloseBracket}]If there is only one expression, and it will print out on one line, then just print everything all on one line, with spaces around the expressions.EtestInit $ putSurroundExpr "{" "}" (CommaSeparated [[Other "hello"]])[Output {outputNestLevel = NestLevel {unNestLevel = 0}, outputOutputType = OutputOpenBrace},Output {outputNestLevel = NestLevel {unNestLevel = 0}, outputOutputType = OutputOther " "},Output {outputNestLevel = NestLevel {unNestLevel = 0}, outputOutputType = OutputOther "hello"},Output {outputNestLevel = NestLevel {unNestLevel = 0}, outputOutputType = OutputOther " "},Output {outputNestLevel = NestLevel {unNestLevel = 0}, outputOutputType = OutputCloseBrace}]~If there is only one expression, but it will print out on multiple lines, then go to newline and print out on multiple lines.1 + 1 -- TODO: Example here.2\If there are multiple expressions, then first go to a newline. Print out on multiple lines.1 + 1 -- TODO: Example here.2 pretty-simpleMA function that performs optimizations and modifications to a list of input ;s. An sample of an optimization is ' which removes empty inner lists in a C value. pretty-simple(Remove empty lists from a list of lists.$removeEmptyList [[1,2,3], [], [4,5]][[1,2,3],[4,5]]removeEmptyList [[]][]removeEmptyList [[1]][[1]]+removeEmptyList [[1,2], [10,20], [100,200]][[1,2],[10,20],[100,200]] pretty-simple!comma separated inner expression.(c) Dennis Gosnell, 2016BSD-style (see LICENSE file)cdep.illabout@gmail.com experimentalPOSIXNone $27>SXצ pretty-simpleLData-type wrapping up all the options available when rendering the list of Xs. pretty-simpleNNumber of spaces to use when indenting. It should probably be either 2 or 4. pretty-simple If this is 1/, then don't colorize the output. If this is 2 colorOptions , then use  colorOptions to colorize the output. pretty-simpleOWhether to replace non-printable characters with hexadecimal escape sequences. pretty-simple<Determines whether pretty-simple should check if the output 3O is a TTY device. Normally, users only want to print in color if the output 3 is a TTY device. pretty-simpleCheck if the output 3! is a TTY device. If the output 3A is a TTY device, determine whether to print in color based on . If not, then set  to 1& so the output does not get colorized. pretty-simpleDon't check if the output 3[ is a TTY device. Determine whether to colorize the output based solely on the value of . pretty-simpleDefault values for 6 when printing to a console with a dark background.  is 4, and  is . pretty-simpleDefault values for 7 when printing to a console with a light background.  is 4, and  is  . pretty-simpleDefault values for > when printing using using ANSI escape sequences for color.  is 4, and  is 1. pretty-simpleGiven I, disable colorful output if the given handle is not connected to a TTY. pretty-simpleGiven  and a list of X , turn the X into a lazy 4. pretty-simpleRender a single X as a &&, using the options specified in the . pretty-simple;Replace non-printable characters with hex escape sequences.escapeNonPrintable "\x1\x2" "\\x1\\x2"Newlines will not be escaped.!escapeNonPrintable "hello\nworld""hello\nworld")Printable characters will not be escaped.escapeNonPrintable "h\101llo""hello" pretty-simple$indentSubsequentLinesWith " " "aaa""aaa".indentSubsequentLinesWith " " "aaa\nbbb\nccc""aaa\n bbb\n ccc"!indentSubsequentLinesWith " " """" pretty-simple Produce a &B corresponding to the ANSI escape sequence for the color for the ", based on whether or not  is 2 or 1, and the value of . pretty-simple Produce a &s corresponding to the ANSI escape sequence for the color for the characters of a string, based on whether or not  is 2 or 1, and the value of . pretty-simple Produce a &s corresponding to the ANSI escape sequence for resetting the console color back to the default. Produces an empty & if  is 1. pretty-simple Produce a &a representing the ANSI escape sequence for the color of the rainbow parenthesis, given an input j and & to use as the input character.If  is 13, then just return the input character. If it is 2,, then return the input character colorized. pretty-simpleThis is simply 5 6 7 8. pretty-simpleMA function that performs optimizations and modifications to a list of input Xs. An sample of an optimization is = which just removes a newline if it is the first item in an X list. pretty-simple Remove a b if it is the first item in the X list.DremoveStartingNewLine [Output 3 OutputNewLine, Output 3 OutputComma]X[Output {outputNestLevel = NestLevel {unNestLevel = 3}, outputOutputType = OutputComma}] pretty-simple)Remove trailing spaces from the end of a f token if it is followed by a b, or if it is the final X< in the list. This function assumes that there is a single f before any bD (and before the end of the list), so it must be run after running .aremoveTrailingSpacesInOtherBeforeNewLine [Output 2 (OutputOther "foo "), Output 4 OutputNewLine][Output {outputNestLevel = NestLevel {unNestLevel = 2}, outputOutputType = OutputOther "foo"},Output {outputNestLevel = NestLevel {unNestLevel = 4}, outputOutputType = OutputNewLine}] pretty-simpleIf there are two subsequent f% tokens, combine them into just one f.KcompressOthers [Output 0 (OutputOther "foo"), Output 0 (OutputOther "bar")]a[Output {outputNestLevel = NestLevel {unNestLevel = 0}, outputOutputType = OutputOther "foobar"}] pretty-simpleIn each f> token, compress multiple whitespaces to just one whitespace.=shrinkWhitespaceInOthers [Output 0 (OutputOther " hello ")]b[Output {outputNestLevel = NestLevel {unNestLevel = 0}, outputOutputType = OutputOther " hello "}] (c) Dennis Gosnell, 2016BSD-style (see LICENSE file)cdep.illabout@gmail.com experimentalPOSIXNoneQ  !"#$%&'()*+,-./01234567;B<=>?@ACDENOPQRSTUVWXYZ[\]^_`abcdefghijkl(c) Dennis Gosnell, 2016BSD-style (see LICENSE file)cdep.illabout@gmail.com experimentalPOSIXNone 27>SXA* pretty-simple&Pretty-print any data type that has a 9 instance.If you've never seen :P before, you can think of this function as having the following type signature:  pPrint :: Show a => a -> IO () HThis function will only use colors if it detects it's printing to a TTY.9This function is for printing to a dark background. Use Q for printing to a terminal with a light background. Different colors are used. Prints to ;. Use  to print to a different 3.pPrint [Just (1, "hello")][ Just ( 1 , "hello" )] pretty-simple Similar to  , but take a 3 to print to."pHPrint stdout [Just (1, "hello")][ Just ( 1 , "hello" )] pretty-simple Similar to , but the first argument is a -1 representing a data type that has already been <ed.2pPrintString $ show [ Just (1, "hello"), Nothing ][ Just ( 1 , "hello" ) , Nothing] pretty-simple Similar to  , but take a 3 to print to.:pHPrintString stdout $ show [ Just (1, "hello"), Nothing ][ Just ( 1 , "hello" ) , Nothing] pretty-simple Similar to L, but print in color regardless of whether the output goes to a TTY or not.See , for an example of how to use this function. pretty-simple Similar to  , but take a 3 to print to.See , for an example of how to use this function. pretty-simple Similar to L, but print in color regardless of whether the output goes to a TTY or not.See , for an example of how to use this function. pretty-simple Similar to L, but print in color regardless of whether the output goes to a TTY or not.See , for an example of how to use this function. pretty-simple Similar to ?, but just return the resulting pretty-printed data type as a 4& instead of printing it to the screen.3This function is for printing to a dark background.See , for an example of how to use this function. pretty-simple Similar to , but the first argument is a -1 representing a data type that has already been <ed.This will work on any - that is similar to a Haskell data type. The only requirement is that the strings are quoted, and braces, parentheses, and brackets are correctly used to represent indentation. For example, " will correctly pretty-print JSON.3This function is for printing to a dark background.See , for an example of how to use this function. pretty-simple Alias for . pretty-simple Alias for . pretty-simple Alias for . pretty-simple Alias for . pretty-simple Alias for . pretty-simple Alias for . pretty-simple Alias for . pretty-simple Alias for . pretty-simple Alias for . pretty-simple Alias for . pretty-simple Just like ), but for printing to a light background. pretty-simple Just like ), but for printing to a light background. pretty-simple Just like ), but for printing to a light background. pretty-simple Just like ), but for printing to a light background. pretty-simple Just like *, but for printing to a light background. pretty-simple Just like *, but for printing to a light background. pretty-simple Just like *, but for printing to a light background. pretty-simple Just like *, but for printing to a light background. pretty-simple Just like ), but for printing to a light background. pretty-simple Just like ), but for printing to a light background. pretty-simple Similar to R, but doesn't print in color. However, data types will still be indented nicely.%pPrintNoColor $ Just ["hello", "bye"]Just [ "hello" , "bye" ] pretty-simpleLike  , but take a 3 to determine where to print to.-pHPrintNoColor stdout $ Just ["hello", "bye"]Just [ "hello" , "bye" ] pretty-simple Similar to R, but doesn't print in color. However, data types will still be indented nicely.2pPrintStringNoColor $ show $ Just ["hello", "bye"]Just [ "hello" , "bye" ] pretty-simpleLike  , but take a 3 to determine where to print to.:pHPrintStringNoColor stdout $ show $ Just ["hello", "bye"]Just [ "hello" , "bye" ] pretty-simpleLike , but without color.+pShowNoColor [ Nothing, Just (1, "hello") ]7"[ Nothing\n, Just\n ( 1\n , \"hello\"\n )\n]" pretty-simpleLIke , but without color.pStringNoColor $ show [1, 2, 3]"[ 1\n, 2\n, 3\n]" pretty-simple Similar to  but takes , to change how the pretty-printing is done. For example, ? can be used to make the indentation much smaller than normal./This is what the normal indentation looks like:MpPrintOpt NoCheckColorTty defaultOutputOptionsNoColor $ Just ("hello", "bye")Just ( "hello" , "bye" ),This is what smaller indentation looks like:Mlet smallIndent = defaultOutputOptionsNoColor {outputOptionsIndentAmount = 1};pPrintOpt CheckColorTty smallIndent $ Just ("hello", "bye")Just ( "hello" , "bye" )Lines in strings get indentedRpPrintOpt NoCheckColorTty defaultOutputOptionsNoColor (1, (2, "foo\nbar\nbaz", 3)) ( 1, ( 2 , "foo bar baz" , 3 ))0Lines get indented even in custom show instancesdata Foo = Foo0instance Show Foo where show _ = "foo\nbar\nbaz"DpPrintOpt CheckColorTty defaultOutputOptionsNoColor (1, (2, Foo, 3)) ( 1, ( 2 , foo bar baz , 3 )) determines whether to test ;. for whether or not it is connected to a TTY. If set to , then  won't check if ;> is a TTY. It will print in color depending on the value of . If set to , then  will check if ; is conneted to a TTY. If ;a is determined to be connected to a TTY, then it will print in color depending on the value of . If ;k is determined to NOT be connected to a TTY, then it will NOT print in color, regardless of the value of . pretty-simple Similar to  , but take a 3! to determine where to print to. pretty-simple Similar to Y, but the last argument is a string representing a data structure that has already been <ed.#let foo = show (1, (2, "hello", 3))=pPrintStringOpt CheckColorTty defaultOutputOptionsNoColor foo( 1, ( 2 , "hello" , 3 )) pretty-simple Similar to  , but take a 3! to determine where to print to.#let foo = show (1, (2, "hello", 3))EpHPrintStringOpt CheckColorTty defaultOutputOptionsNoColor stdout foo( 1, ( 2 , "hello" , 3 )) pretty-simpleLike  but takes , to change how the pretty-printing is done. pretty-simpleLike  but takes , to change how the pretty-printing is done.7 7 (c) Dennis Gosnell, 2017BSD-style (see LICENSE file)cdep.illabout@gmail.com experimentalPOSIXNone0 pretty-simpleThe r function outputs the trace message from the IO monad. This sequences the output with respect to other IO actions. pretty-simpleThe z function pretty prints the trace message given as its first argument, before returning the second argument as its result.'For example, this returns the value of f x but first outputs the message. .pTrace ("calling f with x = " ++ show x) (f x)The  function should only be used for debugging, or for monitoring execution. The function is not referentially transparent: its type indicates that it is a pure function but it has the side effect of outputting the trace message. pretty-simpleLike 2 but returns the message instead of a third value. pretty-simpleLike  , but uses <$ on the argument to convert it to a -.This makes it convenient for printing the values of interesting variables or expressions inside a function. For example here we print the value of the variables x and z: Bf x y = pTraceShow (x, z) $ result where z = ... ... pretty-simpleLike 6 but returns the shown value instead of a third value. pretty-simpleLike $ but returning unit in an arbitrary =3 context. Allows for convenient use in do-notation.Note that the application of  is not an action in the = context, as  is in the >H type. While the fresh bindings in the following example will force the ?* expressions to be reduced every time the do-block is executed, traceM "not crashed"^ would only be reduced once, and the message would only be printed once. If your monad is in MonadIO, liftIO . pTraceIO may be a better option. V... = do x <- ... pTraceM $ "x: " ++ show x y <- ... pTraceM $ "y: " ++ show y pretty-simpleLike  , but uses <$ on the argument to convert it to a -. F... = do x <- ... pTraceShowM $ x y <- ... pTraceShowM $ x + y pretty-simplelike ;, but additionally prints a call stack if one is available.eIn the current GHC implementation, the call stack is only available if the program was compiled with -prof ; otherwise  behaves exactly like +. Entries in the call stack correspond to SCC* annotations, so it is a good idea to use  -fprof-auto or -fprof-auto-calls& to add SCC annotations automatically. pretty-simpleThe  function behaves like @| with the difference that the message is emitted to the eventlog, if eventlog profiling is available and enabled at runtime.:It is suitable for use in pure code. In an IO context use  instead.Note that when using GHC's SMP runtime, it is possible (but rare) to get duplicate events emitted if two CPUs simultaneously evaluate the same thunk that uses . pretty-simpleThe e function emits a message to the eventlog, if eventlog profiling is available and enabled at runtime. Compared to , 6 sequences the event with respect to other IO actions. pretty-simpleThe j function emits a marker to the eventlog, if eventlog profiling is available and enabled at runtime. The Stringx is the name of the marker. The name is just used in the profiling tools to help you keep clear which marker is which.FThis function is suitable for use in pure code. In an IO context use  instead.Note that when using GHC's SMP runtime, it is possible (but rare) to get duplicate events emitted if two CPUs simultaneously evaluate the same thunk that uses . pretty-simpleThe e function emits a marker to the eventlog, if eventlog profiling is available and enabled at runtime. Compared to , 7 sequences the event with respect to other IO actions. pretty-simple Similar to , but forcing color. pretty-simple Similar to , but forcing color. pretty-simple Similar to , but forcing color. pretty-simple Similar to , but forcing color. pretty-simple Similar to , but forcing color. pretty-simple Similar to , but forcing color. pretty-simple Similar to , but forcing color.  pretty-simple Similar to , but forcing color.  pretty-simple Similar to , but forcing color.  pretty-simple Similar to , but forcing color.  pretty-simple Similar to , but forcing color.  pretty-simple Similar to , but forcing color. pretty-simple Similar to , but without color.pTraceNoColor "wow" ()wow() pretty-simple Similar to , but without color.$pTraceIdNoColor "(1, 2, 3)" `seq` ()( 1, 2, 3)() pretty-simple Similar to , but without color.import qualified Data.Map as M-pTraceShowNoColor (M.fromList [(1, True)]) ()fromList [ ( 1 , True ) ]() pretty-simple Similar to , but without color.import qualified Data.Map as M5pTraceShowIdNoColor (M.fromList [(1, True)]) `seq` ()fromList [ ( 1 , True ) ]() pretty-simple Similar to , but without color.pTraceMNoColor "wow"wow pretty-simple Similar to , but without color.pTraceShowMNoColor [1,2,3][ 1, 2, 3] pretty-simple Similar to , but without color.$pTraceStackNoColor "wow" () `seq` ()wow() pretty-simple Similar to , but without color. pretty-simple Similar to , but without color. pretty-simple Similar to , but without color. pretty-simple Similar to , but without color. pretty-simple Similar to , but without color.pTraceIONoColor "(1, 2, 3)"( 1, 2, 3) pretty-simpleLike  but takes OutputOptions. pretty-simpleLike  but takes OutputOptions. pretty-simpleLike  but takes OutputOptions. pretty-simpleLike  but takes OutputOptions. pretty-simpleLike  but takes OutputOptions. pretty-simpleLike  but takes OutputOptions.  pretty-simpleLike  but takes OutputOptions.! pretty-simpleLike  but takes OutputOptions." pretty-simpleLike  but takes OutputOptions.# pretty-simpleLike  but takes OutputOptions.$ pretty-simpleLike  but takes OutputOptions.% pretty-simpleLike  but takes OutputOptions.0      !"#$%0      !"#$%A      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLLMNOPQRSTUVWXYZ[\]^_``abcdefghijklmnopqqrstuvwxyz{|}~      !"#$%&'()*+,-+,.+,/+,0+,1234256278279:;<2=>2=?2@A(BC25D2EF25G2HI2JK2LM2NO2JP25Q:;R2ST2SUV,pretty-simple-3.2.3.0-G6ynjumpgVKAXGuk0T5zK1!Text.Pretty.Simple.Internal.Color Text.Pretty.Simple.Internal.Expr&Text.Pretty.Simple.Internal.ExprParser"Text.Pretty.Simple.Internal.Output(Text.Pretty.Simple.Internal.ExprToOutput)Text.Pretty.Simple.Internal.OutputPrinterText.Pretty.SimpleDebug.Pretty.SimpleText.Pretty.Simple.Internal ColorOptions colorQuote colorString colorErrorcolorNumcolorRainbowParensdefaultColorOptionsDarkBgdefaultColorQuoteDarkBgdefaultColorStringDarkBgdefaultColorErrorDarkBgdefaultColorNumDarkBgdefaultColorRainbowParensDarkBgdefaultColorOptionsLightBgdefaultColorQuoteLightBgdefaultColorStringLightBgdefaultColorErrorLightBgdefaultColorNumLightBg defaultColorRainbowParensLightBgcolorVividBlackBoldcolorVividBlueBoldcolorVividCyanBoldcolorVividGreenBoldcolorVividMagentaBoldcolorVividRedBoldcolorVividWhiteBoldcolorVividYellowBoldcolorDullBlackBoldcolorDullBlueBoldcolorDullCyanBoldcolorDullGreenBoldcolorDullMagentaBoldcolorDullRedBoldcolorDullWhiteBoldcolorDullYellowBoldcolorVividBlackcolorVividBluecolorVividCyancolorVividGreencolorVividMagenta colorVividRedcolorVividWhitecolorVividYellowcolorDullBlack colorDullBlue colorDullCyancolorDullGreencolorDullMagenta colorDullRedcolorDullWhitecolorDullYellow colorBold colorReset colorNull colorHelpersetSGRCodeBuilder$fEqColorOptions$fGenericColorOptions$fShowColorOptionsExprBracketsBracesParens StringLitCharLit NumberLitOtherCommaSeparatedunCommaSeparated$fDataCommaSeparated$fEqCommaSeparated$fGenericCommaSeparated$fShowCommaSeparated $fDataExpr$fEqExpr $fGenericExpr $fShowExpr testString1 testString2expressionParse parseExpr parseExprs parseCSepparseStringLit parseCharLitparseNumberLit parseOtherOutputoutputNestLeveloutputOutputType OutputTypeOutputCloseBraceOutputCloseBracketOutputCloseParen OutputComma OutputIndent OutputNewLineOutputOpenBraceOutputOpenBracketOutputOpenParen OutputOtherOutputStringLit OutputCharLitOutputNumberLit NestLevel unNestLevel$fIsStringOutputType$fDataNestLevel $fEqNestLevel$fGenericNestLevel$fNumNestLevel$fOrdNestLevel$fReadNestLevel$fShowNestLevel$fDataOutputType$fEqOutputType$fGenericOutputType$fReadOutputType$fShowOutputType $fDataOutput $fEqOutput$fGenericOutput $fReadOutput $fShowOutput PrinterStatecurrLine nestLevelLineNum unLineNum printerState addOutput addOutputsinitPrinterStateputSurroundExpr putCommaSepputCommadoIndentnewLinenewLineAndDoIndentaddToNestLeveladdToCurrentLine putExpressionrunPrinterStaterunInitPrinterStateexpressionsToOutputsmodificationsExprList&removeEmptyInnerCommaSeparatedExprList"removeEmptyInnerCommaSeparatedExprremoveEmptyInnerCommaSeparatedremoveEmptyList $fDataLineNum $fEqLineNum$fGenericLineNum $fNumLineNum $fOrdLineNum $fReadLineNum $fShowLineNum$fEqPrinterState$fDataPrinterState$fGenericPrinterState$fShowPrinterState OutputOptionsoutputOptionsIndentAmountoutputOptionsColorOptionsoutputOptionsEscapeNonPrintable CheckColorTtyNoCheckColorTtydefaultOutputOptionsDarkBgdefaultOutputOptionsLightBgdefaultOutputOptionsNoColor hCheckTTYrender renderOutputescapeNonPrintableescapeindentSubsequentLinesWith useColorQuoteuseColorString useColorError useColorNum useColorResetrenderRainbowParenForuseColorRainbowParens sequenceFoldmodificationsOutputListremoveStartingNewLine(removeTrailingSpacesInOtherBeforeNewLinecompressOthersshrinkWhitespaceInOthersshrinkWhitespaceInOthershrinkWhitespace$fEqCheckColorTty$fGenericCheckColorTty$fShowCheckColorTty$fEqOutputOptions$fGenericOutputOptions$fShowOutputOptionspPrintpHPrint pPrintString pHPrintStringpPrintForceColorpHPrintForceColorpPrintStringForceColorpHPrintStringForceColorpShowpString pPrintDarkBg pHPrintDarkBgpPrintStringDarkBgpHPrintStringDarkBgpPrintForceColorDarkBgpHPrintForceColorDarkBgpPrintStringForceColorDarkBgpHPrintStringForceColorDarkBg pShowDarkBg pStringDarkBg pPrintLightBgpHPrintLightBgpPrintStringLightBgpHPrintStringLightBgpPrintForceColorLightBgpHPrintForceColorLightBgpPrintStringForceColorLightBgpHPrintStringForceColorLightBg pShowLightBgpStringLightBg pPrintNoColorpHPrintNoColorpPrintStringNoColorpHPrintStringNoColor pShowNoColorpStringNoColor pPrintOpt pHPrintOptpPrintStringOptpHPrintStringOptpShowOpt pStringOptpTraceIOpTracepTraceId pTraceShow pTraceShowIdpTraceM pTraceShowM pTraceStack pTraceEvent pTraceEventIO pTraceMarkerpTraceMarkerIOpTraceForceColorpTraceIdForceColorpTraceShowForceColorpTraceShowIdForceColorpTraceMForceColorpTraceShowMForceColorpTraceStackForceColorpTraceEventForceColorpTraceEventIOForceColorpTraceMarkerForceColorpTraceMarkerIOForceColorpTraceIOForceColor pTraceNoColorpTraceIdNoColorpTraceShowNoColorpTraceShowIdNoColorpTraceMNoColorpTraceShowMNoColorpTraceStackNoColorpTraceEventNoColorpTraceEventIONoColorpTraceMarkerNoColorpTraceMarkerIONoColorpTraceIONoColor pTraceOpt pTraceIdOpt pTraceShowOptpTraceShowIdOpt pTraceOptIO pTraceOptMpTraceShowOptMpTraceStackOptpTraceEventOptpTraceEventOptIOpTraceMarkerOptpTraceMarkerOptIO text-1.2.3.1Data.Text.Internal.BuilderBuilder+ansi-terminal-0.10.3-DgFqWh2Dtk4EXBq7VKR5GlSystem.Console.ANSI.Types BoldIntensityResetColorIntensityColorSGRbaseGHC.RealRationalGHC.BaseString Data.StringIsString fromStringghc-prim GHC.TypesInt GHC.MaybeNothingJustGHC.IO.Handle.TypesHandleData.Text.Internal.LazyTextfmap Data.Foldablefold.Data.TraversablesequenceGHC.ShowShowControl.Monad.IO.ClassMonadIOGHC.IO.Handle.FDstdoutshow ApplicativeIO Debug.TracetraceMtrace