;^      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL 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 qrstuvwxyz{|}~       !!!!"""""""""" "!"""#"$"%"&"'"(")"*"+","-"."/"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.{.|.}.~..///000000111122222233344445555666777777777777777777777B non-portable experimentalEdward Kmett <ekmett@gmail.com> &The severity of an error (or message) :a non-maskable death sentence thrown by the parser itself a user specified fatal error a user specified error !a warning, computation continues  a comment 9a comment we should only show to the excessively curious *pretty print as a color coded description -Compute the maximum of two diagnostic levels     8 non-portable experimentalEdward Kmett <ekmett@gmail.com> non-portable experimentalEdward Kmett <ekmett@gmail.com>      non-portable experimentalEdward Kmett <ekmett@gmail.com>       non-portable experimentalEdward Kmett <ekmett@gmail.com>  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"#$#$%'&&'()*+)*+,-./012 non-portable experimentalEdward Kmett <ekmett@gmail.com>3456789:;<=>?@ABCDEFGHI3456789:;<=>?@ABCDEFGHI4IHGFEDCBA@?>=<;:98765334IHGFEDCBA@?>=<;:9876556789:;<=>?@ABCDEFGHI non-portable experimentalEdward Kmett <ekmett@gmail.com>JKJKJKJKK  non-portable experimentalEdward Kmett <ekmett@gmail.com>LMNOLMNOLMNOLMNO  non-portable experimentalEdward Kmett <ekmett@gmail.com>PQRSPQRSPQRSPQRSQRS  non-portable experimentalEdward Kmett <ekmett@gmail.com>T<Represents a source file like an HsColour rendered document UVWXY D renderHtml $ toHtml $ addHighlights highlightedRope $ doc "Foo.hs" TUVWXYTUVWXYTUVWXUVWXY  non-portable experimentalEdward Kmett <ekmett@gmail.com>Z[\]^_`abcdefgh4fill the interval from [n .. m) with a given effect ijklcreate a drawing surface mZ[\]^_`abcdefghijklm`abcdefij\]l^_Z[ghkmZ[[\]]^__`abcdefabcdefghijklm  non-portable experimentalEdward Kmett <ekmett@gmail.com>nopnopnopnoop non-portable experimentalEdward Kmett <ekmett@gmail.com>qrstqrstqrstqrstrst non-portable experimentalEdward Kmett <ekmett@gmail.com>uvwuvwuwvuwvvw non-portable experimentalEdward Kmett <ekmett@gmail.com>xyz{|}~xyz{|}~x{zy|}~x{zyyz{|}~ non-portable experimentalEdward Kmett <ekmett@gmail.com> 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    non-portable experimentalEdward Kmett <ekmett@gmail.com> non-portable experimentalEdward Kmett <ekmett@gmail.com> non-portable experimentalEdward Kmett <ekmett@gmail.com> unlocated error -Merge two errors, selecting the most severe. -Merge two errors, selecting the most severe. -Merge two errors, selecting the most severe. -Merge two errors, selecting the most severe.  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   non-portable experimentalEdward Kmett <ekmett@gmail.com>   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; } & ^  non-portable experimentalEdward Kmett <ekmett@gmail.com> non-portable experimentalEdward Kmett <ekmett@gmail.com>  + int main(int argc, char ** argv) { int; } ( ^~~  non-portable experimentalEdward Kmett <ekmett@gmail.com> * int main(int argc char ** argv) { int; }  ^  , 9 non-portable experimentalEdward Kmett <ekmett@gmail.com>Z[\^_l^_\lZ[ 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. ?Called when we enter a nested pair of symbols. Used to disable & layout or highlight nested contexts. *Lexeme parser |semi| parses the character ';' and skips any - trailing white space. Returns the character ';'.  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) #$%&'()*+,-./0123456! !"#$%&'()*+,-./0123456!!"*+/0 #%&$'()-.,123456! !"#$%&'()*+,-./0123456#portable experimentalekmett@gmail.com789:;<=>?@ABCDEFGHI789:;<=>?@ABCDEFGHI7IHGFEDCBA@?>=<;:98789:;<=>?@ABCDEFGHI$portable experimentalekmett@gmail.comJKLMNOPQRSTUVWXYJKLMNOPQRSTUVWXYXYJWPQVUTSRONMLKJKLMNOPQRSTUVWXY%portable experimentalekmett@gmail.com*Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)Z[\]cba`_^dgfehkjilponmqtsru|{zyxwv}~)Z[[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&portable experimentalekmett@gmail.com2///'portable experimentalekmett@gmail.com p      !p      !(portable experimentalekmett@gmail.com"#$%&'()*+,-./01"#$%&'()*+,-./0101"/().-,+*'&%#$"#$%&'()*+,-./01:portable experimentalekmett@gmail.comXY01XY01) non-portable experimentalEdward Kmett <ekmett@gmail.com>2oneOf cs6 succeeds if the current character is in the supplied  list of characters cs). Returns the parsed character. See also  .  vowel = oneOf "aeiou" 3As the dual of 2,  noneOf cs succeeds if the current  character not$ in the supplied list of characters cs. Returns the  parsed character.  consonant = noneOf "aeiou" 4 oneOfSet cs6 succeeds if the current character is in the supplied  set of characters cs). Returns the parsed character. See also  .  vowel = oneOf "aeiou" 5As the dual of 2,  noneOf cs succeeds if the current  character not$ in the supplied list of characters cs. Returns the  parsed character.  consonant = noneOf "aeiou" 6Skips zero* or more white space characters. See also  and   whiteSpace. 7>Parses a white space character (any character which satisfies )  Returns the parsed character. 8Parses a newline character ('\n'!). Returns a newline character. 9Parses 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. Achar c parses a single character c. Returns the parsed  character (i.e. c).  semiColon = char ';' B notChar c( parses any single character other than c. Returns the parsed  character.  semiColon = char ';' CGThis parser succeeds for any character. Returns the parsed character. Dstring s* parses a sequence of characters given by s . Returns  the parsed string (i.e. s).  divOrMod = string "div"  <|> string "mod" E byteString s% parses a sequence of bytes given by s . Returns  the parsed byteString (i.e. s).  divOrMod = string "div"  <|> string "mod" 23456789:;<=>?@ABCDE23456789:;<=>?@ABCDE23456789:;<=>?@ABCDE* non-portable provisionalekmett@gmail.com FGHIJKLMNOPUse this to easily build the definition of whiteSpace for your MonadTokenParser FGHIJKLMNO FGHIJKLNMO FGHIJKGHIJKLMNO+ non-portable provisionalekmett@gmail.comP;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. QR9This 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 S6This parser parses a natural number (a positive whole = number). Returns the value of the number. The number can be  specified in W, X or  Y0. The number is parsed according to the grammar  rules in the Haskell report. 3This parser does NOT swallow trailing whitespace. T<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 W, X  or Y!. 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. U=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. VThis 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. WBParses a positive whole number in the decimal system. Returns the  value of the number. XEParses a positive whole number in the hexadecimal system. The number  should be prefixed with "x" or "X". Returns the value of the  number. Y?Parses a positive whole number in the octal system. The number  should be prefixed with "o" or "O". Returns the value of the  number. PQRSTUVWXY PQRSTUVWXY PQRSTUVWXY, non-portable provisionalekmett@gmail.comZlexeme 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)  } [BThis 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). \@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). ]=This lexeme parser parses a natural number (a positive whole = number). Returns the value of the number. The number can be  specified in W, X or  Y0. The number is parsed according to the grammar  rules in the Haskell report. ^CThis lexeme parser parses an integer (a whole number). This parser  is like ]% except that it can be prefixed with  sign (i.e. '-' or '+'(). Returns the value of the number. The  number can be specified in W, X  or Y!. The number is parsed according . to the grammar rules in the Haskell report. _DThis 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. `!This lexeme parser parses either ] 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. aLexeme parser symbol s parses D s and skips  trailing white space. bLexeme parser  symbolic s parses A s and skips  trailing white space. cLexeme parser parens p parses p enclosed in parenthesis,  returning the value of p. dLexeme parser braces p parses p enclosed in braces ('{' and  '}'), returning the value of p. eLexeme parser angles p parses p enclosed in angle brackets ('<'  and '>'), returning the value of p. fLexeme parser  brackets p parses p enclosed in brackets ('['  and ']'), returning the value of p. gLexeme parser comma parses the character ',' and skips any * trailing white space. Returns the string ",". hLexeme parser colon parses the character ':' and skips any * trailing white space. Returns the string ":". iLexeme parser dot parses the character '.' and skips any * trailing white space. Returns the string ".". jLexeme parser  semiSep p parses zero or more occurrences of p  separated by '. Returns a list of values returned by  p. kLexeme parser  semiSep1 p parses one or more occurrences of p  separated by '. Returns a list of values returned by p. lLexeme parser  commaSep p parses zero or more occurrences of  p separated by g$. Returns a list of values returned  by p. mLexeme parser  commaSep1 p parses one or more occurrences of  p separated by g$. Returns a list of values returned  by p. Z[\]^_`abcdefghijklmZ[\]^_`abcdefghijklmZ[\]^_`abcdefghijklm- non-portable provisionalekmett@gmail.com nopqrstuv2Lift an identifier style into a monad transformer w<parse a reserved operator or identifier using a given style xTparse a reserved operator or identifier using a given style specified by bytestring y+parse an non-reserved identifier or symbol nopqrstuvwxy nopqrstuvywx nopqrstuopqrstuvwxy; non-portable experimentalEdward Kmett <ekmett@gmail.com>'WXYZ[\]^_`abcdefghijklmnopqrstuvwxyWXY.z{|}~z{|}~z{|}~z{|}~{|}~/0 non-portable experimentalEdward Kmett <ekmett@gmail.com>12 non-portable provisionalekmett@gmail.com3 non-portable provisionalekmett@gmail.com< non-portable experimentalEdward Kmett <ekmett@gmail.com>z{|}~z{|}~45 non-portable experimentalEdward Kmett <ekmett@gmail.com>= non-portable experimentalEdward Kmett <ekmett@gmail.com>  67non-portable (mptcs, fundeps) experimentalekmett@gmail.comUsing 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. 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 ';' char c parses a single character c. Returns the parsed  character (i.e. c).  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 experimentalEdward Kmett <ekmett@gmail.com>34JKJK43? non-portable experimentalEdward Kmett <ekmett@gmail.com> PQRS PQRS@ non-portable experimentalEdward Kmett <ekmett@gmail.com>uvw     23456789:;<=>?@ABCDEWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~A non-portable experimentalEdward Kmett <ekmett@gmail.com>( Z[\^_lnop(nop^_\lZ[ B non-portable experimentalEdward Kmett <ekmett@gmail.com>      !"#$%&'()*+,-./0123456789:;<=>? 34JKPQRSZ[\^_lnopuvw     23456789:;<=>?@ABCDEWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~@CDECDFCDGHIJKLMNOPQRSTUVWXYZ[\]]^_^`abcdeefgghiijklmnopqrstuvwxyz{|}~           U        ~ !"#$%&'(()*+,-./0123456789:;;<=>?@ A B!C!C!r!D"E"E"F"G"H"I"J"K"L"m"M"N"O"n"P"Q"R"S"T"U"D"V"W"X"Y"Z"["r"\"]"^"_"`#a#b#c#d#e#f#g#h#i#j##k#l#m#n#o#p#q#r$s$e$o$t$u$h$c$d$v$g$w$x$b$y$z${%|%|%}%~%%%%%%j%%%%%b%%%n%%%%%m%%%%k%%%%%%%%l%a%%%%%&&&&&&&&&&~&&&&&&j&&&&&b&&&n&&&&&m&&&&k&&&&&&&&l&a&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ' ' ' ' '''''(s(o(e(t(u(h(c(d(v(g(w(x(b(y(())))))b)))d)c)f)j)h))i)))) )!*"*"*#*$*%*&*'*(*)**+++,+-+.+/+0+1+2+3+4,5,6,7,8,9,:,;,m,<,=,>,?,@,A,B,C,D,E,F,G-H-H-I-J-K-L-M-N-O-P-Q-R.S.S.T.U.V.W/X/Y/Z0[0\0]0^0_0`1a1a1b1c2d2e2f2g2h2i3j3k3l4m4n4o4p5v5v5q5r6s6t6u7777777b777d7c7f7j7h77i7777 7!vw8x8y8z8{8|8}~CC       o!!!!!"""""""""""""%&&&''C++++k++++++++++22CD trifecta-0.44 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.ErrText.Trifecta.Parser.Class(Text.Trifecta.Diagnostic.Rendering.Caret"Text.Trifecta.Diagnostic.Err.State'Text.Trifecta.Diagnostic.Rendering.Span(Text.Trifecta.Diagnostic.Rendering.FixitText.Trifecta.Parser.PermText.Trifecta.Parser.Expr Text.Trifecta.Parser.Token.Class Text.Trifecta.Parser.Layout.Prim!Text.Trifecta.Parser.Layout.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.StyleText.Trifecta.Parser.Token.Prim&Text.Trifecta.Parser.Token.Combinators%Text.Trifecta.Parser.Token.Identifier!Text.Trifecta.Parser.Language.Def#Text.Trifecta.Parser.Language.Class)Text.Trifecta.Parser.Language.Combinators#Text.Trifecta.Parser.Language.Monad+Text.Trifecta.Parser.Token.Identifier.Style#Text.Trifecta.Parser.Language.Style'Text.Trifecta.Parser.Layout.Combinators!Text.Trifecta.Parser.Layout.MonadText.Trifecta.Parser.HaskellText.Trifecta.Parser.Char8Text.Trifecta.Util"Text.Trifecta.Diagnostic.RenderingText.Trifecta.CharSet.PosixText.Trifecta.Parser.TokenText.Trifecta.Parser.LanguageText.Trifecta.Parser.LayoutText.Trifecta.HighlightText.Trifecta.RopeText.Trifecta.ParserText.Trifecta.Diagnostic Text.TrifectabaseControl.ApplicativeoptionalmanysomeDiagnosticLevelPanicFatalErrorWarningNoteVerboseHasBytesbytesHasDeltadeltaDeltaDirectedLinesTabColumnscolumn columnBytenextTabrewindnearRopeStrand LineDirectivestrandropestrandsgrabRestgrabLine IntervalMaprunIntervalMap IntInterval NoIntervalIntervallowhighoffset singletoninsert dominatorssearch intersectionsfromList Highlights HighlightMatchedSymbolsLayoutUnboundBadInputReservedConstructorOperatorConstructorOperatorReservedConstructor ConstructorReservedOperatorOperatorReservedIdentifier IdentifierSymbolSpecial StatementConstant StringLiteral CharLiteralCommentNumber EscapeCode Highlightable addHighlightshighlightEffects pushTokenpopToken withHighlightHighlightedRoperopeHighlights ropeContentDocdocTitledocCss docContentdocRendered:@Sourcesource Renderablerender RenderingrenderingDeltarenderingLineLenrenderingLineBytes renderingLinerenderingOverlaysdraw nullRenderingemptyRenderingifNear rendering.# DiagnostictellDiagnosticErrLogerrLog errHighlightsResultFailureSuccessStepStepContStepFailStepDonefeedstarve stepResultItPure simplifyItneedItwantItrunItfillItstepItrewindItsliceItMonadDiagnostic fatalWitherrWithlogWithfatalerrwarnnoteverbosewarnWithnoteWith verboseWithErrPanicErrFailErrEmptyErrknownErrfatalErr MonadParsertrylabelsskipManysatisfysatisfy8 highlightliftItmark unexpectedlinerelease satisfyAsciiskipping restOfLine slicedWithslicedrendCareted:^Caret caretEffects drawCaretaddCaretcaretcaretedErrState errExpected errMessageSpanned:~Span spanEffectsdrawSpanaddSpanspanspannedFixit fixitSpanfixitReplacement drawFixitaddFixitfixitchoiceoption skipOptionalbetweenskipSomesepBysepBy1 sepEndBy1sepEndByendBy1endBycountchainrchainlchainl1chainr1manyTilleof notFollowedBy lookAheadPerm<||><$$><|?><$?>permute OperatorTablePostfixPrefixInfixAssoc AssocRight AssocLeft AssocNonebuildExpressionParserMonadTokenParser whiteSpacenestingsemi LayoutState _layoutBol _layoutStack LayoutContextDisabledLayoutIndentedLayout LayoutTokenOther WhiteSpaceVirtualRightBrace VirtualSemidefaultLayoutState layoutBol layoutStackMonadLayoutParserlayout getLayout setLayout modLayoutParserunparser 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 byteString CommentStyle commentStart commentEnd commentLinecommentNestingemptyCommentStylejavaCommentStylehaskellCommentStylebuildWhiteSpaceParser charLiteral' characterCharstringLiteral'natural'integer'double'naturalOrDouble'decimal hexadecimaloctallexeme charLiteral stringLiteralnaturalintegerdoublenaturalOrDoublesymbolicparensbracesanglesbracketscommacolondotsemiSepsemiSep1commaSep commaSep1IdentifierStyle styleName styleStart styleLetter styleReservedstyleHighlightstyleReservedHighlightliftIdentifierStylereservereserveByteStringident LanguageDeflanguageCommentStylelanguageIdentifierslanguageOperatorsliftLanguageDef MonadLanguage askLanguage asksLanguage identifierreservedreservedByteStringop reservedOpreservedOpByteStringLanguage unlanguage runLanguageemptyOps haskell98Ops haskellOps emptyIdentshaskell98Idents haskellIdentsemptyLanguageDefhaskellLanguageDefhaskell98LanguageDef disableLayout enableLayoutlaidoutlayoutEqunlayout runLayoutHaskellhaskell haskell98$fPrettyTermDiagnosticLevel$fSemigroupDiagnosticLevelargminargmaxfromLazytoLazytakeLine<$!>int64 Data.FoldableFoldableData.Traversable TraversableNode largerErroratleastgreater$fHasUnionIntervalMapLocatedoutOfRangeEffects///growrecolorwindow $fComonadIt $fMonoidErr$fSemigroupErr $fPlusErr$fAltErrBranchnewPermaddaddOptStNoStJuStIshiftRshiftLindexcharSetheadByteposneguluholohnumChars 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