lq{      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l mnopqrstuvwxyz{|}~                               !! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A#B#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#b#c#d#e#f#g#h#i#j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% & & & & &&&&&&&&&&&&''''''' '!'"'#'$'%'&'''(')'*'+','-(.(/(0(1(2(3(4(5(6(7(8)9):);)<)=)>)?)@)A)B*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,b,c,d,e,f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z-6     .{|}~{|}~{|}~             Dgrab a the contents of a rope from a given location up to a newline !Dgrab a the contents of a rope from a given location up to a newline  !  !  !<non-portable (MPTCs, type families, functional dependencies) experimentalekmett@gmail.com"3Map of closed intervals, possibly with duplicates.  The  and $ instances process the intervals in  lexicographical order. #$%&'(AA closed interval. The lower bound should be less than or equal  to the higher bound. )*+,O(n)*. Add a delta to each interval in the map -O(1)%. Interval map with a single entry. .O(log n)". Insert an interval into a map. I The map may contain duplicate intervals; the new entry will be inserted 4 before any existing entries for the same interval. / O(k log (n/k))2. All intervals that contain the given interval,  in lexicographical order. 0 O(k log (n/k))/. All intervals that contain the given point,  in lexicographical order. 1 O(k log (n/k))/. All intervals that intersect with the given % interval, in lexicographical order. 2 O(m log (n/m)). Merge two interval maps. G The map may contain duplicate intervals; entries with equal intervals ! are kept in the original order. "#$%&'()*+,-./012()*+"#$-.01/,%'&2"#$#$%'&&'()*+)*+,-./0123456789:;<=>?@ABCDE3456789:;<=>?@ABCDE4EDCBA@?>=<;:98765334EDCBA@?>=<;:9876556789:;<=>?@ABCDEFGFGFGFGG HIJKHIJKHIJKHIJK LMNOLMNOLMNOLMNOMNO P<Represents a source file like an HsColour rendered document QRSTU D renderHtml $ toHtml $ addHighlights highlightedRope $ doc "Foo.hs" PQRSTUPQRSTUPQRSTQRSTU VWXYZ[\]^_`abcd4fill the interval from [n .. m) with a given effect efghcreate a drawing surface iVWXYZ[\]^_`abcdefghi\]^_`abefXYhZ[VWcdgiVWWXYYZ[[\]^_`ab]^_`abcdefghi jkljkljkljkklmnopmnopmnopmnopnopqrsqrsqsrqsrrstuvwxyztuvwxyztwvuxyztwvuuvwxyz {|}~FGiven a position, go there, and grab the text forward from that point ;Return the text of the line that contains a given position It is a cofree comonad {|}~ {}|~ {}||}~unlocated error  non-portable experimentalekmett@gmail.comhTake a parser that may consume input, and on failure, go back to where we started and fail as if we didn't consume input. iA version of many that discards its input. Specialized because it can often be implemented more cheaply. ;Parse a single character of the input, with UTF-8 decoding 9Parse a single byte of the input, without UTF-8 decoding  highlight, is called internally in the token parsers. E It delimits ranges of the input recognized by certain parsers that ? are useful for syntax highlighting. An interested monad could A choose to listen to these events and construct an interval tree % for later pretty printing purposes. .Lift an operation from the primitive It monad Ymark the current location so it can be used in constructing a span, or for later seeking -Used to emit an error on an unexpected token KRetrieve the contents of the current line (from the beginning of the line) (Seek back to previously marked location 'grab the remainder of the current line label a parser with a name Hrun a parser, grabbing all of the text between its start and end points krun a parser, grabbing all of the text between its start and end points and discarding the original result     In file included from baz.c:9  In file included from bar.c:4  foo.c:8:36: note + int main(int argc, char ** argv) { int; } & ^   + int main(int argc, char ** argv) { int; } ( ^~~  * int main(int argc char ** argv) { int; }  ^  , /VWXZ[hZ[XhVW non-portable experimentalekmett@gmail.com choice ps( tries to apply the parsers in the list ps in order, A until one of them succeeds. Returns the value of the succeeding  parser.  option x p tries to apply parser p. If p fails without ' consuming input, it returns the value x, otherwise the value  returned by p. ' priority = option 0 (do{ d <- digit 3 ; return (digitToInt d)  }) skipOptional p tries to apply parser p. It will parse p or nothing.  It only fails if p5 fails after consuming input. It discards the result  of p. (Plays the role of parsec',s optional, which conflicts with Applicative' s optional) between open close p parses open, followed by p and close.  Returns the value returned by p. . braces = between (symbol "{") (symbol "}")  skipSome p applies the parser p one or more times, skipping ' its result. (aka skipMany1 in parsec)  sepBy p sep parses zero or more occurrences of p , separated  by sep'. Returns a list of values returned by p. ' commaSep p = p `sepBy` (symbol ",")  sepBy1 p sep parses one or more occurrences of p , separated  by sep'. Returns a list of values returned by p. sepEndBy1 p sep parses one or more occurrences of p, # separated and optionally ended by sep. Returns a list of values  returned by p. sepEndBy p sep parses zero or more occurrences of p, # separated and optionally ended by sep, ie. haskell style 2 statements. Returns a list of values returned by p. 8 haskellStatements = haskellStatement `sepEndBy` semi  endBy1 p sep parses one or more occurrences of p , seperated  and ended by sep'. Returns a list of values returned by p.  endBy p sep parses zero or more occurrences of p , seperated  and ended by sep'. Returns a list of values returned by p. * cStatements = cStatement `endBy` semi  count n p parses n occurrences of p. If n is smaller or % equal to zero, the parser equals to return []. Returns a list of  n values returned by p.  chainr p op x parser zero or more occurrences of p,  separated by op Returns a value obtained by a right associative * application of all functions returned by op to the values returned  by p!. If there are no occurrences of p , the value x is  returned.  chainl p op x parser zero or more occurrences of p,  separated by op . Returns a value obtained by a left associative * application of all functions returned by op to the values returned  by p#. If there are zero occurrences of p , the value x is  returned. chainl1 p op x parser one or more occurrences of p,  separated by op Returns a value obtained by a left associative * application of all functions returned by op to the values returned  by p:. . This parser can for example be used to eliminate left : recursion which typically occurs in expression grammars. # expr = term `chainl1` addop # term = factor `chainl1` mulop $ factor = parens expr <|> integer  - mulop = do{ symbol "*"; return (*) } - <|> do{ symbol "/"; return (div) }  + addop = do{ symbol "+"; return (+) } + <|> do{ symbol "-"; return (-) } chainr1 p op x parser one or more occurrences of |p|,  separated by op Returns a value obtained by a right associative * application of all functions returned by op to the values returned  by p. manyTill p end applies parser p zero or more times until  parser end2 succeeds. Returns the list of values returned by p. + This parser can be used to scan comments:  & simpleComment = do{ string "<!--" > ; manyTill anyChar (try (string "-->"))  } Note the overlapping parsers anyChar and string "-->", and  therefore the use of the  combinator. AThis parser only succeeds at the end of the input. This is not a * primitive parser but it is defined using . 2 eof = notFollowedBy anyChar <?> "end of input" notFollowedBy p only succeeds when parser p fails. This parser F does not consume any input. This parser can be used to implement the  ' longest match'3 rule. For example, when recognizing keywords (for  example let7), we want to make sure that a keyword is not followed ? by a legal identifier character, in which case the keyword is % actually an identifier (for example lets). We can program this  behaviour as follows: & keywordLet = try (do{ string "let" 0 ; notFollowedBy alphaNum  })  lookAhead p parses p without consuming any input.  non-portable provisionalekmett@gmail.com  The type Perm m a$ denotes a permutation parser that,  when converted by the  function, parses  using the base parsing monad m and returns a value of  type a on success. ENormally, a permutation parser is first build with special operators  like (,) and than transformed into a normal parser  using . The expression perm <||> p adds parser p to the permutation  parser perm . The parser p( is not allowed to accept empty input -  use the optional combinator () instead. Returns a & new permutation parser that includes p. The expression f <$$> p$ creates a fresh permutation parser  consisting of parser p*. The the final result of the permutation  parser is the function f applied to the return value of p. The  parser p9 is not allowed to accept empty input - use the optional  combinator ( ) instead. If the function f2 takes more than one parameter, the type variable  bA is instantiated to a functional type which combines nicely with  the adds parser p to the () combinator. This C results in stylized code where a permutation parser starts with a  combining function f' followed by the parsers. The function f F gets its parameters in the order in which the parsers are specified, ' but actual input can be in any order. The expression perm < ||> (x,p) adds parser p to the  permutation parser perm . The parser p is optional - if it can # not be applied, the default value x will be used instead. Returns < a new permutation parser that includes the optional parser p. The expression f < $?> (x,p)$ creates a fresh permutation parser  consisting of parser p*. The the final result of the permutation  parser is the function f applied to the return value of p. The  parser p; is optional - if it can not be applied, the default value  x will be used instead.  The parser  permute perm* parses a permutation of parser described  by perm:. For example, suppose we want to parse a permutation of:  an optional string of a's, the character b and an optional c.  This can be described by: 3 test = permute (tuple <$?> ("",some (char 'a')) ( <||> char 'b' . <|?> ('_',char 'c'))  where ! tuple a b c = (a,b,c)  non-portable experimentalekmett@gmail.com An OperatorTable m a is a list of  Operator m a * lists. The list is ordered in descending E precedence. All operators in one list have the same precedence (but & may have a different associativity). ?This data type specifies operators that work on values of type a. B An operator is either binary infix or unary prefix or postfix. A 7 binary operator has also an associated associativity. EThis data type specifies the associativity of operators: left, right  or none.  buildExpressionParser table term! builds an expression parser for  terms term with operators from table, taking the associativity  and precedence specified in table" into account. Prefix and postfix < operators of the same precedence can only occur once (i.e. --2 is  not allowed if -1 is prefix negate). Prefix and postfix operators 7 of the same precedence associate to the left (i.e. if ++ is  postfix increment, than -2++ equals -1, not -3). The buildExpressionParser" takes care of all the complexity B involved in building expression parser. Here is an example of an D expression parser that handles prefix signs, postfix increment and  basic arithmetic. - expr = buildExpressionParser table term  <?> "expression"   term = parens expr  <|> natural " <?> "simple expression"  2 table = [ [prefix "-" negate, prefix "+" id ] " , [postfix "++" (+1)] F , [binary "*" (*) AssocLeft, binary "/" (div) AssocLeft ] F , [binary "+" (+) AssocLeft, binary "-" (-) AssocLeft ]  ]  K binary name fun assoc = Infix (do{ reservedOp name; return fun }) assoc F prefix name fun = Prefix (do{ reservedOp name; return fun }) G postfix name fun = Postfix (do{ reservedOp name; return fun })  non-portable experimentalekmett@gmail.com0Parses any white space. White space consists of zero or more  occurrences of a space#, a line comment or a block (multi ? line) comment. Block comments may be nested. How comments are . started and ended is defined by this method. lexeme p first applies parser p and then the   parser, returning the value of p. Every lexical ! token (lexeme) is defined using lexeme, this way every parse 9 starts at a point without white space. Parsers that use lexeme are  called lexeme parsers in this document. The only point where the  parser should be D called explicitly is the start of the main parser in order to skip  any leading white space. " mainParser = do { whiteSpace 1 ; ds <- many (lexeme digit)  ; eof ' ; return (sum ds)  }  non-portable experimentalekmett@gmail.com non-portable (mptcs, fundeps) experimentalekmett@gmail.comparseFromFile p filePath runs a parser p on the  input read from filePath using ByteString.readFile. All diagnostic messages T emitted over the course of the parse attempt are shown to the user on the console.  main = do 0 result <- parseFromFile numbers "digits.txt"  case result of  Nothing -> return ()  Just a -> print $ sum a parseFromFileEx p filePath runs a parser p on the  input read from filePath using ByteString.readFile". Returns all diagnostic messages R emitted over the course of the parse and the answer if the parse was successful.  main = do 8 result <- parseFromFileEx (many number) "digits.txt"  case result of 7 Failure xs -> unless (Seq.null xs) $ displayLn xs  Success xs a -> + unless (Seq.null xs) $ displayLn xs  print $ sum a  unknown experimentalekmett@gmail.com Check the set for membership.  ,non-portable (Data, BangPatterns, MagicHash) experimentalekmett@gmail.com.O(n) worst case  O(n)     !     !     !     !portable experimentalekmett@gmail.com !"#$%&'()*+,-./0 !"#$%&'()*+,-./00/.-,+*)('&%$#"!  !"#$%&'()*+,-./0"portable experimentalekmett@gmail.com123456789:;<=>?@123456789:;<=>?@?@1>78=<;:965432123456789:;<=>?@#portable experimentalekmett@gmail.com*ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi)ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi)ABCDJIHGFEKNMLORQPSWVUTX[ZY\cba`_^]dihgfe)ABBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi$portable experimentalekmett@gmail.com2jklmnopqrstuvwxyz{|}~/jklmnopqrstuvwxyz{|}~/jklmnopqrsyxwvutz}|{~/jklmnoklmnopqrstuvwxyz{|}~%portable experimentalekmett@gmail.com pp&portable experimentalekmett@gmail.com                    0portable experimentalekmett@gmail.com?@?@'oneOf cs6 succeeds if the current character is in the supplied  list of characters cs). Returns the parsed character. See also  .  vowel = oneOf "aeiou" As the dual of ,  noneOf cs succeeds if the current  character not$ in the supplied list of characters cs. Returns the  parsed character.  consonant = noneOf "aeiou"  oneOfSet cs6 succeeds if the current character is in the supplied  set of characters cs). Returns the parsed character. See also  .  vowel = oneOf "aeiou" As the dual of ,  noneOf cs succeeds if the current  character not$ in the supplied list of characters cs. Returns the  parsed character.  consonant = noneOf "aeiou" Skips zero* or more white space characters. See also  and   whiteSpace. >Parses a white space character (any character which satisfies )  Returns the parsed character. Parses a newline character ('\n'!). Returns a newline character.  Parses a tab character ('\t'). Returns a tab character. !1Parses an upper case letter (a character between 'A' and 'Z').  Returns the parsed character. "3Parses a lower case character (a character between 'a' and 'z').  Returns the parsed character. #.Parses a letter or digit (a character between '0' and '9').  Returns the parsed character. $EParses a letter (an upper case or lower case character). Returns the  parsed character. %/Parses a digit. Returns the parsed character. &8Parses a hexadecimal digit (a digit or a letter between 'a' and  'f' or 'A' and 'F'"). Returns the parsed character. '+Parses an octal digit (a character between '0' and '7' ). Returns  the parsed character. (char c parses a single character c. Returns the parsed  character (i.e. c).  semiColon = char ';' ) notChar c( parses any single character other than c. Returns the parsed  character.  semiColon = char ';' *GThis parser succeeds for any character. Returns the parsed character. +string s* parses a sequence of characters given by s . Returns  the parsed string (i.e. s).  divOrMod = string "div"  <|> string "mod" , byteString s% parses a sequence of bytes given by s . Returns  the parsed byteString (i.e. s).  divOrMod = string "div"  <|> string "mod"  !"#$%&'()*+, !"#$%&'()*+, !"#$%&'()*+,( non-portable provisionalekmett@gmail.com -./012345<parse a reserved operator or identifier using a given style 6Tparse a reserved operator or identifier using a given style specified by bytestring 7+parse an non-reserved identifier or symbol -./01234567 -./01234756 -./01234./01234567) non-portable provisionalekmett@gmail.com8;This parser parses a single literal character. Returns the C literal character value. This parsers deals correctly with escape E sequences. The literal character is parsed according to the grammar E rules defined in the Haskell report (which matches most programming  languages quite closely). 3This parser does NOT swallow trailing whitespace. 9:9This parser parses a literal string. Returns the literal F string value. This parsers deals correctly with escape sequences and C gaps. The literal string is parsed according to the grammar rules ? defined in the Haskell report (which matches most programming  languages quite closely). 1This parser does NOT swallow trailing whitespace ;6This parser parses a natural number (a positive whole = number). Returns the value of the number. The number can be  specified in ?, @ or  A0. The number is parsed according to the grammar  rules in the Haskell report. 3This parser does NOT swallow trailing whitespace. <<This parser parses an integer (a whole number). This parser  is like natural% except that it can be prefixed with  sign (i.e. '-' or '+'(). Returns the value of the number. The  number can be specified in ?, @  or A!. The number is parsed according . to the grammar rules in the Haskell report. 3This parser does NOT swallow trailing whitespace. Also, unlike the integer+ parser, this parser does not admit spaces " between the sign and the number. ==This parser parses a floating point value. Returns the value D of the number. The number is parsed according to the grammar rules ! defined in the Haskell report. 3This parser does NOT swallow trailing whitespace. >This parser parses either natural or a double. : Returns the value of the number. This parsers deals with F any overlap in the grammar rules for naturals and floats. The number J is parsed according to the grammar rules defined in the Haskell report. 3This parser does NOT swallow trailing whitespace. ?BParses a positive whole number in the decimal system. Returns the  value of the number. @EParses a positive whole number in the hexadecimal system. The number  should be prefixed with "x" or "X". Returns the value of the  number. A?Parses a positive whole number in the octal system. The number  should be prefixed with "o" or "O". Returns the value of the  number. 89:;<=>?@A 89:;<=>?@A 89:;<=>?@A* non-portable provisionalekmett@gmail.comBBThis lexeme parser parses a single literal character. Returns the C literal character value. This parsers deals correctly with escape E sequences. The literal character is parsed according to the grammar E rules defined in the Haskell report (which matches most programming  languages quite closely). C@This lexeme parser parses a literal string. Returns the literal F string value. This parsers deals correctly with escape sequences and C gaps. The literal string is parsed according to the grammar rules ? defined in the Haskell report (which matches most programming  languages quite closely). D=This lexeme parser parses a natural number (a positive whole = number). Returns the value of the number. The number can be  specified in ?, @ or  A0. The number is parsed according to the grammar  rules in the Haskell report. ECThis lexeme parser parses an integer (a whole number). This parser  is like D% except that it can be prefixed with  sign (i.e. '-' or '+'(). Returns the value of the number. The  number can be specified in ?, @  or A!. The number is parsed according . to the grammar rules in the Haskell report. FDThis lexeme parser parses a floating point value. Returns the value D of the number. The number is parsed according to the grammar rules ! defined in the Haskell report. G!This lexeme parser parses either D or a float. : Returns the value of the number. This parsers deals with F any overlap in the grammar rules for naturals and floats. The number J is parsed according to the grammar rules defined in the Haskell report. HLexeme parser symbol s parses + s and skips  trailing white space. ILexeme parser  symbolic s parses ( s and skips  trailing white space. JLexeme parser parens p parses p enclosed in parenthesis,  returning the value of p. KLexeme parser braces p parses p enclosed in braces ('{' and  '}'), returning the value of p. LLexeme parser angles p parses p enclosed in angle brackets ('<'  and '>'), returning the value of p. MLexeme parser  brackets p parses p enclosed in brackets ('['  and ']'), returning the value of p. N*Lexeme parser |semi| parses the character ';' and skips any * trailing white space. Returns the string ";". OLexeme parser comma parses the character ',' and skips any * trailing white space. Returns the string ",". PLexeme parser colon parses the character ':' and skips any * trailing white space. Returns the string ":". QLexeme parser dot parses the character '.' and skips any * trailing white space. Returns the string ".". RLexeme parser  semiSep p parses zero or more occurrences of p  separated by N'. Returns a list of values returned by  p. SLexeme parser  semiSep1 p parses one or more occurrences of p  separated by N'. Returns a list of values returned by p. TLexeme parser  commaSep p parses zero or more occurrences of  p separated by O$. Returns a list of values returned  by p. ULexeme parser  commaSep1 p parses one or more occurrences of  p separated by O$. Returns a list of values returned  by p. BCDEFGHIJKLMNOPQRSTUBCDEFGHIJKLMNOPQRSTUBCDEFGHIJKLMNOPQRSTU1%-./01234567?@ABCDEFGHIJKLMNOPQRSTU?@A+ non-portable provisionalekmett@gmail.com VWXYZ[\]^_PUse this to easily build the definition of whiteSpace for your MonadTokenParser VWXYZ[\]^_ VWXYZ[\^]_ VWXYZ[WXYZ[\]^_, non-portable provisionalekmett@gmail.com`abcde`abcdeced`ba`abcde-non-portable (mptcs, fundeps) experimentalekmett@gmail.comfUsing this instead of "Text.Trifecta.Parser.Class.satisfy B you too can time travel back to when men were men and characters < fit into 8 bits like God intended. It might also be useful D when writing lots of fiddly protocol code, where the UTF8 decoding  is probably a very bad idea. goneOf cs6 succeeds if the current character is in the supplied  list of characters cs). Returns the parsed character. See also  f.  vowel = oneOf "aeiou" hAs the dual of g,  noneOf cs succeeds if the current  character not$ in the supplied list of characters cs. Returns the  parsed character.  consonant = noneOf "aeiou" i oneOfSet cs6 succeeds if the current character is in the supplied  set of characters cs). Returns the parsed character. See also  f.  vowel = oneOf "aeiou" jAs the dual of g,  noneOf cs succeeds if the current  character not$ in the supplied list of characters cs. Returns the  parsed character.  consonant = noneOf "aeiou" kSkips zero* or more white space characters. See also  and   whiteSpace. l>Parses a white space character (any character which satisfies )  Returns the parsed character. mParses a newline character ('\n'!). Returns a newline character. nParses a tab character ('\t'). Returns a tab character. o1Parses an upper case letter (a character between 'A' and 'Z').  Returns the parsed character. p3Parses a lower case character (a character between 'a' and 'z').  Returns the parsed character. q.Parses a letter or digit (a character between '0' and '9').  Returns the parsed character. rEParses a letter (an upper case or lower case character). Returns the  parsed character. s/Parses a digit. Returns the parsed character. t8Parses a hexadecimal digit (a digit or a letter between 'a' and  'f' or 'A' and 'F'"). Returns the parsed character. u+Parses an octal digit (a character between '0' and '7' ). Returns  the parsed character. vchar c parses a single character c. Returns the parsed  character (i.e. c).  semiColon = char ';' wchar c parses a single character c. Returns the parsed  character (i.e. c).  semiColon = char ';' xGThis parser succeeds for any character. Returns the parsed character. ystring s* parses a sequence of characters given by s . Returns  the parsed string (i.e. s).  divOrMod = string "div"  <|> string "mod" z byteString s% parses a sequence of bytes given by s . Returns  the parsed byteString (i.e. s).  divOrMod = string "div"  <|> string "mod" fghijklmnopqrstuvwxyzfghijklmnopqrstuvwxyzfghijklmnopqrstuvwxyz23456789:;<=>?@ABCDEFG3 LMNO LMNO4uqrs !"#$%&'()*+,-./01234567?@ABCDEFGHIJKLMNOPQRSTU5( VWXZ[hjkl(jklZ[XhVW 6 3456789:;<=>?@ABCDEFGLMNOVWXZ[hjklqrs !"#$%&'()*+,-./01234567?@ABCDEFGHIJKLMNOPQRSTU78978:78;<=>?@ABCDEFGHIJKLMNOPQQRSRTUVWXYYZ[[\]]^_`abcdefghijklmnopqrstuvwxyz{ | } ~            I      n  f ! ! " # $ % & ' ( a ) * + b , - . / 0 1  2 3 4 5 6 7 f 8 9 : ; <!=!>!?!@!A!B!C!D!E!F!!G!H!I!J!K!L!M!N"O"A"K"P"Q"D"?"@"R"C"S"T">"U"V"W#X#X#Y#Z#[#\#]#^#_#F#`#a#b##>#c#d#J#e#f#g#h#I#i#j#k#G#l#m#n#o#p#q#r#H#=#s#t#u#v#w$x$x$y$z${$|$}$~$$Z$[$\$]$^$_$F$`$a$b$$>$c$d$J$e$f$g$h$I$i$j$k$G$l$m$n$o$p$q$r$H$=$s$t$u$v$w%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&O&K&A&P&Q&D&?&@&R&C&S&T&>&U&&''''''>'''@'?'B'F'D''E'''''((((((((((()) ) ) ) ) ))))*******I********* *!*"*#*$+%+%+&+'+(+)+*+++,+-,.,/,0,1,2,3------->---@-?-B-F-D--E-----.4.5.6.7.8.9:7;<7=>??@ABC D  E F G H IJKKLMNOPQKRRSTU V W X Y Z [ \ ] ^ _ ` a b#c$d$e$c%d%e7fg)h)i)j)G)k)l)m)n)o)p)q)r)s)t,u,v78wxyzxy{xy|xy}xy~xyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxyxy trifecta-0.40 Text.Trifecta.Parser.CombinatorsText.Trifecta.Diagnostic.LevelText.Trifecta.Rope.BytesText.Trifecta.Rope.DeltaText.Trifecta.Rope.PrimText.Trifecta.IntervalMapText.Trifecta.Highlight.PrimText.Trifecta.Highlight.ClassText.Trifecta.Highlight.EffectsText.Trifecta.Rope.Highlighted&Text.Trifecta.Highlight.Rendering.HTML'Text.Trifecta.Diagnostic.Rendering.PrimText.Trifecta.Diagnostic.Prim Text.Trifecta.Diagnostic.Err.LogText.Trifecta.Parser.ResultText.Trifecta.Parser.StepText.Trifecta.Parser.ItText.Trifecta.Diagnostic.Class$Text.Trifecta.Diagnostic.CombinatorsText.Trifecta.Diagnostic.Err"Text.Trifecta.Diagnostic.Err.StateText.Trifecta.Parser.Class(Text.Trifecta.Diagnostic.Rendering.Caret'Text.Trifecta.Diagnostic.Rendering.Span(Text.Trifecta.Diagnostic.Rendering.FixitText.Trifecta.Parser.PermText.Trifecta.Parser.Expr Text.Trifecta.Parser.Token.ClassText.Trifecta.Parser.PrimText.Trifecta.Parser.ByteStringText.Trifecta.ByteSetText.Trifecta.CharSetText.Trifecta.CharSet.Common!Text.Trifecta.CharSet.Posix.AsciiText.Trifecta.CharSet.Unicode&Text.Trifecta.CharSet.Unicode.Category#Text.Trifecta.CharSet.Unicode.Block#Text.Trifecta.CharSet.Posix.UnicodeText.Trifecta.Parser.Char%Text.Trifecta.Parser.Token.IdentifierText.Trifecta.Parser.Token.Prim&Text.Trifecta.Parser.Token.Combinators Text.Trifecta.Parser.Token.Style+Text.Trifecta.Parser.Token.Identifier.StyleText.Trifecta.Parser.Char8Text.Trifecta.Util"Text.Trifecta.Diagnostic.RenderingText.Trifecta.CharSet.PosixText.Trifecta.Parser.TokenText.Trifecta.HighlightText.Trifecta.RopeText.Trifecta.ParserText.Trifecta.Diagnostic Text.TrifectabaseControl.ApplicativeoptionalmanysomeDiagnosticLevelPanicFatalErrorWarningNoteVerboseHasBytesbytesHasDeltadeltaDeltaDirectedLinesTabColumnscolumn columnBytenextTabrewindnearRopeStrand LineDirectivestrandropestrandsgrabRestgrabLine IntervalMaprunIntervalMap IntInterval NoIntervalIntervallowhighoffset singletoninsert dominatorssearch intersectionsfromList Highlights HighlightReservedConstructorOperatorConstructorOperatorReservedConstructor ConstructorReservedOperatorOperatorReservedIdentifier IdentifierSymbolSpecial StatementConstant StringLiteral CharLiteralCommentNumber EscapeCode Highlightable addHighlightshighlightEffects pushTokenpopToken withHighlightHighlightedRoperopeHighlights ropeContentDocdocTitledocCss docContentdocRendered:@Sourcesource Renderablerender RenderingrenderingDeltarenderingLineLenrenderingLineBytes renderingLinerenderingOverlaysdraw nullRenderingemptyRenderingifNear rendering.# DiagnostictellDiagnosticErrLogerrLog errHighlightsResultFailureSuccessStepStepContStepFailStepDonefeedstarve stepResultItPure simplifyItneedItwantItrunItfillItstepItrewindItsliceItMonadDiagnostic fatalWitherrWithlogWithfatalerrwarnnoteverbosewarnWithnoteWith verboseWithErrPanicErrFailErrEmptyErrknownErrfatalErrErrState errExpected errMessage MonadParsertrylabelsskipManysatisfysatisfy8 highlightliftItmark unexpectedlinerelease satisfyAsciiskipping restOfLine slicedWithslicedrendCareted:^Caret caretEffects drawCaretaddCaretcaretcaretedSpanned:~Span spanEffectsdrawSpanaddSpanspanspannedFixit fixitSpanfixitReplacement drawFixitaddFixitfixitchoiceoption skipOptionalbetweenskipSomesepBysepBy1 sepEndBy1sepEndByendBy1endBycountchainrchainlchainl1chainr1manyTilleof notFollowedBy lookAheadPerm<||><$$><|?><$?>permute OperatorTablePostfixPrefixInfixAssoc AssocRight AssocLeft AssocNonebuildExpressionParserMonadTokenParser whiteSpacelexemeParserunparser manyAccum stepParserwhy parseTest parseFromFileparseFromFileExByteSetmemberCharSet\\buildmapisComplementedtoList toAscListemptyfullnullsizerangedelete complementunion intersection difference notMemberfoldfilter partitionoverlaps isSubsetOf fromAscListfromDistinctAscList fromCharSet toCharSettoArraycontrolspacelowerupperalphaalphaNumprintdigitoctDigitletternumber punctuationsymbol separatorasciilatin1 asciiUpper asciiLoweralnumblankcntrlgraphwordpunctxdigit posixAsciilookupPosixAsciiCharSetUnicodeCategoryunicodeCategorieslowercaseLetteruppercaseLettertitlecaseLetter letterAndmodifierLetter otherLetternonSpacingMarkspacingCombiningMark enclosingMark lineSeparatorparagraphSeparator mathSymbolcurrencySymbolmodifierSymbol otherSymbol decimalNumber letterNumber otherNumberdashPunctuationopenPunctuationclosePunctuation initialQuote finalQuoteconnectorPunctuationotherPunctuationformat privateUse surrogate notAssignedotherCategory categoryNamecategoryAbbreviationcategoryCharSetcategoryDescription categorieslookupCategorylookupCategoryCharSetBlock blockName blockCharSetblocks lookupBlocklookupBlockCharSet basicLatinlatin1SupplementlatinExtendedAlatinExtendedB ipaExtensionsspacingModifierLetterscombiningDiacriticalMarksgreekAndCopticcyrilliccyrillicSupplementaryarmenianhebrewarabicsyriacthaana devanagaribengaligurmukhigujaratioriyatamiltelugukannada malayalamsinhalathailaotibetanmyanmargeorgian hangulJamoethiopiccherokee"unifiedCanadianAboriginalSyllabicsoghamrunictagaloghanunoobuhidtagbanwakhmer mongolianlimbutaiLe khmerSymbolsphoneticExtensionslatinExtendedAdditional greekExtendedgeneralPunctuationsuperscriptsAndSubscriptscurrencySymbols#combiningDiacriticalMarksForSymbolsletterlikeSymbols numberFormsarrowsmathematicalOperatorsmiscellaneousTechnicalcontrolPicturesopticalCharacterRecognitionenclosedAlphanumerics boxDrawing blockElementsgeometricShapesmiscellaneousSymbolsdingbats!miscellaneousMathematicalSymbolsAsupplementalArrowsAbraillePatternssupplementalArrowsB!miscellaneousMathematicalSymbolsB!supplementalMathematicalOperatorsmiscellaneousSymbolsAndArrowscjkRadicalsSupplementkangxiRadicals ideographicDescriptionCharacterscjkSymbolsAndPunctuationhiraganakatakanabopomofohangulCompatibilityJamokanbunbopomofoExtendedkatakanaPhoneticExtensionsenclosedCjkLettersAndMonthscjkCompatibilitycjkUnifiedIdeographsExtensionAyijingHexagramSymbolscjkUnifiedIdeographs yiSyllables yiRadicalshangulSyllableshighSurrogateshighPrivateUseSurrogates lowSurrogatesprivateUseAreacjkCompatibilityIdeographsalphabeticPresentationFormsarabicPresentationFormsAvariationSelectorscombiningHalfMarkscjkCompatibilityFormssmallFormVariantsarabicPresentationFormsBhalfwidthAndFullwidthFormsspecials posixUnicodelookupPosixUnicodeCharSetoneOfnoneOfoneOfSet noneOfSetspacesnewlinetabhexDigitcharnotCharanyCharstring byteStringIdentifierStyle styleName styleStart styleLetter styleReservedstyleHighlightstyleReservedHighlightreservereserveByteStringident charLiteral' characterCharstringLiteral'natural'integer'double'naturalOrDouble'decimal hexadecimaloctal charLiteral stringLiteralnaturalintegerdoublenaturalOrDoublesymbolicparensbracesanglesbracketssemicommacolondotsemiSepsemiSep1commaSep commaSep1 CommentStyle commentStart commentEnd commentLinecommentNestingemptyCommentStylejavaCommentStylehaskellCommentStylebuildWhiteSpaceParseremptyOps haskell98Ops haskellOps emptyIdentshaskell98Idents haskellIdentsargminargmaxfromLazytoLazytakeLine<$!>int64 Data.FoldableFoldableData.Traversable TraversableNode largerErroratleastgreater$fHasUnionIntervalMapLocatedoutOfRangeEffects///growrecolorwindow $fComonadItBranchnewPermaddaddOptStNoStJuStIshiftRshiftLindexcharSetheadByteposneguluholohnumChars charSetTyConfromListConstrcomplementConstrcharSetDataTypecat lookupTable canonicalize GHC.UnicodeisSpace charEscape charLetter escapeCodesignintnat zeroNumberfloating fractExponent natDouble zeroNumFloat decimalFloat fractFloatsethaskell98ReservedIdents Alternativewl-pprint-terminfo-0.8.1#System.Console.Terminfo.PrettyPrint displayDoc'' displayDoc' displayDocdisplay displayLn evalTermState displayCapwhitecyanmagentablueyellowgreenblackredstandoutdim invisible protectedreversed underlineboldblink background foregroundsoftwithringBoldStandout UnderlineReverseBlinkDim Invisible Protected Foreground BackgroundElseNop ScopedEffectVisibleBellOnlyAudibleBellOnlyVisibleBellPreferredAudibleBellPreferredBellPushPopRingEffectTermDoc SimpleTermDoceffect HasEffectprettyTermList prettyTerm PrettyTerm