!X:      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab c d e f g h i j k l m n o p q r s t u v w x y z { | } ~               (C) 2011-2019 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableSafe84A(c) Edward Kmett 2011-2019 (c) Ross Paterson 2008 BSD-styleekmett@gmail.com experimental<non-portable (MPTCs, type families, functional dependencies)None =?@AHV( trifecta8Map of closed intervals, possibly with duplicates. The  and ; instances process the intervals in lexicographical order.trifectaVA closed interval. The lower bound should be less than or equal to the higher bound. trifectaO(n)). Add a delta to each interval in the map trifectaO(1)$. Interval map with a single entry. trifectaO(log n). Insert an interval into a map. The map may contain duplicate intervals; the new entry will be inserted before any existing entries for the same interval.trifecta O(k log (n/k))L. All intervals that contain the given interval, in lexicographical order.trifecta O(k log (n/k))I. All intervals that contain the given point, in lexicographical order.trifecta O(k log (n/k))S. All intervals that intersect with the given interval, in lexicographical order.%trifecta O(m log (n/m)). Merge two interval maps. The map may contain duplicate intervals; entries with equal intervals are kept in the original order.     (C) 2011-2019 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableSafe+r (C) 2011-2019 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableSafe27>! 0trifecta;Since there are multiple ways to be at a certain location, 03 captures all these alternatives as a single type.1trifecta +( number of characters , number of bytes ) 2trifecta _( number of characters before the tab , number of characters after the tab , number of bytes ) 3trifecta ( number of newlines contained , number of characters since the last newline , number of bytes , number of bytes since the last newline ) 4trifecta ( current file name , number of lines since the last line directive , number of characters since the last newline , number of bytes , number of bytes since the last newline ) 7trifecta Example: file.txt:12:348trifecta@Retrieve the character offset within the current line from this 0.9trifecta;Retrieve the byte offset within the current line from this 0.:trifecta.Increment a column number to the next tabstop.;trifecta Rewind a 0 to the beginning of the line.<trifecta!Should we show two things with a 0 on the same line? near (Columns 0 0) (Columns 5 5)True$near (Lines 1 0 1 0) (Lines 2 4 4 2)False./0312456789:;<03124./567:;<89(C) 2011-2019 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableSafe 27=?@AHV[[QtrifectaData of a certain lengthRtrifecta#Absence of data of a certain lengthStrifectaConstruct a single P out of a .Utrifecta Construct a N out of a single  strand.Wtrifecta"Grab the entire rest of the input Nf, starting at an initial offset, or return a default if we re already at or beyond the end. Also see X.4Extract a suffix of a certain length from the input:sgrabRest (delta ("Hello " :: ByteString)) (ropeBS "Hello World\nLorem") Nothing (\x y -> Just (x, Lazy.toString y))!Just (Columns 6 6,"World\nLorem")%Same deal, but over multiple strands:ugrabRest (delta ("Hel" :: ByteString)) (ropeBS "Hello" <> ropeBS "World") Nothing (\x y -> Just (x, Lazy.toString y))Just (Columns 3 3,"loWorld")4When the offset is too long, fall back to a default:lgrabRest (delta ("OffetTooLong" :: ByteString)) (ropeBS "Hello") Nothing (\x y -> Just (x, Lazy.toString y))Nothingtrifecta&Split the rope in two halves, given a 0 offset from the beginning.Xtrifecta;Grab the rest of the line at a certain offset in the input NK, or return a default if there is no newline left in the input. Also see W.grabLine (delta ("Hello " :: ByteString)) (ropeBS "Hello" <> ropeBS " World\nLorem") Nothing (\x y -> Just (x, Strict.toString y))Just (Columns 6 6,"World\n")WtrifectaInitial offsettrifectaInputtrifecta'Default value if there is no input lefttrifecta'If there is some input left, create an r7 out of the data from the initial offset until the endXtrifectaInitial offsettrifectaInputtrifecta'Default value if there is no input lefttrifecta'If there is some input left, create an rC out of the data from the initial offset until the end of the line NOPQRSTUVWX NOTUPQRSVWX(C) 2011-2019 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableSafe @AFHV jtrifectaj is an  0https://wiki.haskell.org/Enumerator_and_iterateeIteratee# that can produce partial results.j r a consumes a feed of rs and produces a+s on the way. New values can be fed using m<, the current (partial or final) result is extracted using .let keepIt a = Pure a let replaceIt a = It a replaceItextract (keepIt 0)0extract (replaceIt 0)0!extract (simplifyIt (keepIt 0) 5)0$extract (simplifyIt (replaceIt 0) 5)5ktrifecta+Final result, rest of the feed is discardedltrifecta8Intermediate result, consumed values produce new resultsmtrifectaFeed a value to j,, obtaining a new (partial or final) result.ntrifecta-Consumes input until a value can be produced.:{Olet needTen = needIt 0 (\n -> if n < 10 then Nothing else Just n) :: It Int Int:}extract needTen0extract (simplifyIt needTen 5)0extract (simplifyIt needTen 11)11>extract (simplifyIt (simplifyIt (simplifyIt needTen 5) 11) 15)11otrifectaNConsumes input and produces partial results until a condition is met. Unlike nP, partial results are already returned when the condition is not fulfilled yet. S>>> :{ let wantTen :: It Int Int wantTen = wantIt 0 (\n -> (# n >= 10, n #)) :} >>> extract wantTen 0 $>>> extract (simplifyIt wantTen 5) 5 &>>> extract (simplifyIt wantTen 11) 11 E>>> extract (simplifyIt (simplifyIt (simplifyIt wantTen 5) 11) 15) 11ptrifecta>The generalized fold (Bhm-Berarducci decoding) over 'It r a'.p satisfies the property: foldIt Pure It = idqtrifectaScott decoding of 'It r a'.The scott decoding is similar to the generalized fold over a data type, but leaves the recursion step to the calling function.q satiesfies the property: runIt Pure It = id%See also the Scott decoding of lists: +runList :: (a -> [a] -> b) -> b -> [a] -> band compare it with * (the Bhm-Berarducci decoding for lists): 'foldr :: (a -> b -> b) -> b -> [a] -> brtrifectaSGiven a position, go there, and grab the rest of the line forward from that point.:set -XOverloadedStringsTlet secondLine = fillIt Nothing (const Just) (delta ("foo\nb" :: Strict.ByteString))extract secondLineNothing.extract (simplifyIt secondLine (ropeBS "foo"))Nothing3extract (simplifyIt secondLine (ropeBS "foo\nbar")) Just "ar"8extract (simplifyIt secondLine (ropeBS "foo\nbar\nbaz")) Just "ar\n"strifecta:Return the text of the line that contains a given position:set -XOverloadedStringsAlet secondLine = rewindIt (delta ("foo\nb" :: Strict.ByteString))extract secondLineNothing.extract (simplifyIt secondLine (ropeBS "foo"))Nothing3extract (simplifyIt secondLine (ropeBS "foo\nbar")) Just "bar"8extract (simplifyIt secondLine (ropeBS "foo\nbar\nbaz")) Just "bar\n"ttrifecta$Return the text between two offsets.:set -XOverloadedStringsklet secondLine = sliceIt (delta ("foo\n" :: Strict.ByteString)) (delta ("foo\nbar\n" :: Strict.ByteString))extract secondLine"".extract (simplifyIt secondLine (ropeBS "foo"))""3extract (simplifyIt secondLine (ropeBS "foo\nbar"))"bar"8extract (simplifyIt secondLine (ropeBS "foo\nbar\nbaz"))"bar\n"utrifectaj is a cofree comonadntrifectaInitial resulttrifectaProduce a result if possibleotrifectaInitial resulttrifecta!Produce a partial or final result jklmnopqrst jklnompqrst(C) 2011-2019 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableNone27=?@A|trifectaA |3 is a canvas of text that output can be written to.trifecta(focus, the render will keep this visibletrifectaactual line lengthtrifectaline length in bytes~trifecta0A raw canvas to paint ANSI-styled characters on.trifectaRemove a number of (index, element) values from an .trifectaA  is a  with a suggestion.dunAnnotate (prettyRendering (addFixit (Columns 35 35) (Columns 38 38) "Fix this!" exampleRendering))21 | int main(int argc, char ** argv) { int; }<EOF>* | ~~~0 | Fix this!trifecta where the error occurredtrifectaReplacement suggestiontrifecta+Annotate an arbitrary piece of data with a ., typically its corresponding input location.trifectaA ' marks a range of input characters. If  is a point, then  is a line.WunAnnotate (prettyRendering (addSpan (Columns 35 35) (Columns 38 38) exampleRendering))21 | int main(int argc, char ** argv) { int; }<EOF>* | ~~~trifectaA * marks a point in the input with a simple ^ character.HunAnnotate (prettyRendering (addCaret (Columns 35 35) exampleRendering))21 | int main(int argc, char ** argv) { int; }<EOF>( | ^trifecta 8( Number of (padded) columns , number of bytes , line ) trifectaIs the | empty?nullRendering emptyRenderingTruenullRendering exampleRenderingFalsetrifecta The empty | , which contains nothing at all.%show (prettyRendering emptyRendering)""trifectacreate a drawing surfacetrifecta-ANSI terminal style for rendering the gutter.trifecta,ANSI terminal style for rendering the caret.trifecta*Render a caret at a certain position in a |.trifecta)ANSI terminal style to render spans with.trifectaANSI style to usetrifectaLine; 0 is at the toptrifectaColumn; 0 is on the lefttrifectaData to be writtentrifectaCanvas to draw ontrifecta Position 1trifecta0Modify the fallback result if the positions are < each othertrifecta Position 2trifecta)Fallback result if the positions are not < each othertrifectaStart of the region of interesttrifectaEnd of the region of interesttrifectaCurrrent locationtrifecta~ to add the rendering to5|}~5|}~(c) Edward Kmett 2011-2019BSD3ekmett@gmail.com experimental non-portableNone456=>?@ACSXÂtrifectaThis is used to report an error. What went wrong, some supplemental docs and a set of things expected at the current location. This does not, however, include the actual location. trifectaA # that lets you embed or retrieve a   in a potentially larger type. trifectaCThe result of parsing. Either we succeeded or something went wrong.trifectaGenerate a simple $ word-wrapping the supplied message.trifecta Convert a |! of auxiliary information and an @ into a 'Doc AnsiStyle', ready to be prettyprinted to the user.trifecta Fold over a  trifectaThe  for the  constructor of  trifectaThe  for the  constructor of          (C) 2011-2019 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableNones*trifectaA * is a N with an associated  full of highlighted regions.,trifecta Convert a  into a coloration on a .-trifecta;Represents a source file like an HsColour rendered document@trifecta-Generate an HTML document from a title and a *.*+,-./012;<=>?@*+/012,-.;<=>?@5(c) Edward Kmett 2011-2019BSD3ekmett@gmail.com experimental non-portableNone=>?@ACKCtrifectaThis class is a refinement of Ff that adds the ability to mark your position in the input and return there for further parsing later.DtrifectaYmark the current location so it can be used in constructing a span, or for later seekingEtrifecta!Seek a previously marked locationFtrifecta0This class provides parsers with easy access to:<1) the current line contents. 2) the current position as a 0. 3) the ability to use L on any parser.GtrifectaJRetrieve the contents of the current line (from the beginning of the line)Htrifecta#Retrieve the current position as a 0.ItrifectaGRun a parser, grabbing all of the text between its start and end pointsJtrifecta Retrieve a |> of the current line noting this position, but not placing a  there.Ktrifecta&Grab the remainder of the current lineLtrifectakRun a parser, grabbing all of the text between its start and end points and discarding the original resultMtrifectaGrab a " pointing to the current location.NtrifectaParse a  result. Pointing the  to where you start.Otrifecta+Discard the result of a parse, returning a 0 from where we start to where it ended parsing.PtrifectaParse a  result. The 3 starts here and runs to the last position parsed.Qtrifecta Grab a fixit.CEDFGHIJKLMNOPQFGHIJKLMNOPQCED (c) Edward Kmett 2011-2019BSD3ekmett@gmail.com experimental non-portableNone456=>?@ACSX9 btrifectaA b1 allows for incremental parsing, since the parsercan be done with a final result have errored<can have yielded a partial result with possibly more to comectrifecta&Parsing is done and has converted the N to a final resultdtrifecta Parsing the N has failed with an erroretrifectaThe N3 has been partially consumed and already yielded a  ?, and if more input is provided, more results can be produced.One common scenario for this is to parse log files: after parsing a single line, that data can already be worked with, but there may be more lines to come.ftrifectaThe type of a trifecta parser4The first four arguments are behavior continuations:epsilon success: the parser has consumed no input and has a result as well as a possible Err; the position and chunk are unchanged (see )epsilon failure: the parser has consumed no input and is failing with the given Err; the position and chunk are unchanged (see )committed success: the parser has consumed input and is yielding the result, set of expected strings that would have permitted this parse to continue, new position, and residual chunk to the continuation.ucommitted failure: the parser has consumed input and is failing with a given ErrInfo (user-facing error message)The remaining two arguments arethe current position+the chunk of input currently under analysisf is an /; trifecta's backtracking behavior encoded as  is to behave as the leftmost parser which yields a value (regardless of any input being consumed) or which consumes input and fails. That is, a choice of parsers will only yield an epsilon failure if *all* parsers in the choice do. If that is not the desired behavior, see e, which turns a committed parser failure into an epsilon failure (at the cost of error information).jtrifecta Feed some additional input to a b# to continue parsing a bit further.ktrifecta\Assume all possible input has been given to the parser, execute it to yield a final result.ntrifectaIncremental parsing. A b& can be supplied with new input using j , the final   is obtained using k.otrifectaRun a f# on input that can be reduced to a N, e.g. , or $. See also the monomorphic versions s and r.ptrifecta(p p filePath) runs a parser p on the input read from filePath using  m. All diagnostic messages emitted over the course of the parse attempt are shown to the user on the console. main = do result <- parseFromFile numbers "digits.txt" case result of Nothing -> return () Just a -> print $ sum aqtrifecta(q p filePath) runs a parser p on the input read from filePath using  t. Returns all diagnostic messages emitted over the course of the parse and the answer if the parse was successful. main = do result <- parseFromFileEx (many number) "digits.txt" case result of Failure xs -> displayLn xs Success a -> print (sum a)rtrifectaFully parse a  to a  .parseByteString p delta i runs a parser p on i.strifectaFully parse a  to a  .parseByteString p delta i runs a parser p on i.ntrifecta"Starting cursor position. Usually  for the beginning of the file.otrifecta"Starting cursor position. Usually  for the beginning of the file.rtrifecta"Starting cursor position. Usually  for the beginning of the file.strifecta"Starting cursor position. Usually  for the beginning of the file.bcdefghijklmnopqrstfghibcdejknlmopqsrt(C) 2011-2019 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableNone      !"#$%&NOPQRSTUVWX|}~    *+,-./012;<=>?@CEDFGHIJKLMNOPQbcdefghijklmnopqrst None:trifecta^In order to keep things minimal, we define a very simple language for arithmetic expressions.trifecta expr + exprtrifecta 1, 2, -345, &trifectaFirst, we import Trifecta itself. It only the core parser definitions and instances. Since Trifecta on its own is just the parser and a handful of instances; the bulk of the utility functions is actually from a separate package, parsers2, that provides the usual parsing functions like  , !, and so on. The idea behind the parsers package is that most parser libraries define the same generic functions, so they were put into their own package to be shared. Trifecta reexports these definitions, but it s useful to keep in mind that the documentation of certain functions might not be directly in the trifecta package.trifectaThe parser is straightforward: there are literal integers, and parenthesized additions. We require parentheses in order to keep the example super simple as to not worry about operator precedence.It is useful to use  tokenizing functions to write parsers. Roughly speaking, these automatically skip trailing whitespace on their own, so that the parser isn t cluttered with skipWhitespace calls.  for example parses a 'G and then skips trailing whitespace; there is also the more primitive  : function that just parses its argument and nothing else.trifecta'We can now use our parser to convert a  to an , -parseString parseExpr mempty "(1 + (2 + 3))"  +Success (Add (Lit 1) (Add (Lit 2) (Lit 3)))vWhen we provide ill-formed input, we get a nice error message with an arrow to the location where the error occurred: ,parseString parseExpr mempty "(1 + 2 + 3))" J(interactive):1:8: error: expected: ")" 1 | (1 + 2 + 3))<EOF> | ^( !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]]^^_`abcdefghijklmnopqrstuvwxwyz{|}~B       !"#$%&'()*+,-.//01123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd e f g h i i j k l m n o p q r s t u v w x y z { | } ~                                  !"#$%&'()*+,-./012345678"trifecta-2.1-1VM4tpPDimvdvWAJyZ5f0Text.Trifecta.HighlightText.Trifecta.Util.IntervalMapText.Trifecta.DeltaText.Trifecta.RopeText.Trifecta.Util.ItText.Trifecta.RenderingText.Trifecta.ResultText.Trifecta.CombinatorsText.Trifecta.ParserText.Trifecta.TutorialText.Trifecta.Util.CombinatorsText.Trifecta.Util.Pretty ByteStringreadFile Text.Trifecta&parsers-0.12.10-Lopw0is64pe6ZMHLF7JeWFText.Parser.Token.Highlight Highlight IntervalMaprunIntervalMap IntInterval NoIntervalIntervallowhighoffset singletoninsert dominatorssearch intersectionsfromList$fTraversableInterval$fFoldableInterval$fFunctorInterval $fOrdInterval $fEqInterval$fReducervInterval$fSemigroupInterval"$fTraversableWithIndexIntervalNode$fTraversableNode$fFoldableWithIndexIntervalNode$fFoldableNode$fFunctorWithIndexIntervalNode $fFunctorNode$fMeasuredIntIntervalNode$fSemigroupIntInterval$fMonoidIntInterval$fSemigroupIntervalMap$fMonoidIntervalMap$fHasUnion0IntervalMap$fHasUnionIntervalMap $fMeasuredIntIntervalIntervalMap)$fTraversableWithIndexIntervalIntervalMap$fTraversableIntervalMap&$fFoldableWithIndexIntervalIntervalMap$fFoldableIntervalMap%$fFunctorWithIndexIntervalIntervalMap$fFunctorIntervalMap$fShowIntervalHasDeltadeltaDeltaColumnsTabLinesDirectedHasBytesbytes prettyDeltacolumn columnBytenextTabrewindnear$fHasBytesFingerTree$fHasBytesByteString$fSemigroupDelta $fMonoidDelta$fHashableDelta$fHasBytesDelta $fOrdDelta $fEqDelta$fHasDeltaFingerTree$fHasDeltaByteString$fHasDeltaWord8$fHasDeltaChar$fHasDeltaDelta$fHasDeltaEither $fShowDelta $fDataDelta$fGenericDeltaRopeStrandSkippingstrandroperopeBSstrandsgrabRestgrabLine$fHasBytesStrand$fHasDeltaStrand$fHashableStrand$fMeasuredDeltaStrand$fReducer[]Rope$fReducerByteStringRope$fReducerStrandRope$fReducerRopeRope$fSemigroupRope $fMonoidRope$fMeasuredDeltaRope$fHasDeltaRope$fHasBytesRope $fShowStrand $fDataStrand$fGenericStrand $fShowRopeItPure simplifyItneedItwantItfoldItrunItfillItrewindItsliceIt $fComonadIt$fComonadApplyIt $fMonadIt$fApplicativeIt$fProfunctorIt $fFunctorIt$fShowIt RenderingdrawFixit _fixitSpan_fixitReplacementSpanned:~HasSpanspanSpanCareted:^HasCaretcaretCaretRendered:@Sourcesource Renderablerender HasRendering renderingrenderingDelta renderingLinerenderingLineBytesrenderingLineLenrenderingOverlays nullRenderingemptyRenderingifNearrendered.#prettyRendering gutterEffects caretEffects drawCaretaddCaretrenderingCaret spanEffectsdrawSpanaddSpan drawFixitaddFixit$fHasDeltaRendering$fMonoidRendering$fSemigroupRendering$fShowRendering$fHasRenderingRendering$fRenderableRendering$fSourceByteString $fSource[]$fRenderableRendered$fTraversableRendered$fFoldableRendered$fComonadApplyRendered$fComonadRendered$fHasBytesRendered$fHasDeltaRendered$fFunctorRendered$fSemigroupCaret$fReducerCaretRendering$fRenderableCaret$fHasDeltaCaret$fHasBytesCaret$fHashableCaret$fHasCaretCaret$fHashableCareted$fReducerCaretedRendering$fRenderableCareted$fTraversableCareted$fFoldableCareted$fComonadApplyCareted$fComonadCareted$fHasBytesCareted$fHasDeltaCareted$fFunctorCareted$fHasCaretCareted$fHashableSpan$fReducerSpanRendering$fSemigroupSpan$fRenderableSpan $fHasSpanSpan$fHashableSpanned$fRenderableSpanned$fReducerSpannedRendering$fTraversableSpanned$fFoldableSpanned$fComonadApplySpanned$fComonadSpanned$fFunctorSpanned$fHasSpanSpanned$fShowRendered $fEqCaret $fOrdCaret $fShowCaret $fDataCaret$fGenericCaret $fEqCareted $fOrdCareted $fShowCareted $fDataCareted$fGenericCareted$fEqSpan $fOrdSpan $fShowSpan $fDataSpan $fGenericSpan $fEqSpanned $fOrdSpanned $fShowSpanned $fDataSpanned$fGenericSpanned $fEqFixit $fOrdFixit $fShowFixit $fDataFixit$fGenericFixitHasFixitfixitfixitReplacement fixitSpan$fRenderableFixit$fReducerFixitRendering$fHashableFixit$fHasSpanFixit$fHasFixitFixitErr_reason _footnotes _expected _finalDeltasErrInfo_errDoc _errDeltas $fShowErrInfoAsResult_ResultResultSuccessFailureErrableraiseErrHasErrerrexpected finalDeltas footnotesreasonfailedexplain foldResult_Success_Failure$fSemigroupErrInfo$fMonoidErrInfo $fMonoidErr$fSemigroupErr $fHasErrErr $fMonadResult$fAlternativeResult$fApplicativeResult$fAsResultResultResultab $fShowResult$fFunctorResult$fFoldableResult$fTraversableResultHighlightedRope withHighlight HighlightDocHasHighlightedRopehighlightedRope ropeContentropeHighlights$fMonoidHighlightedRope$fSemigroupHighlightedRope$fHasBytesHighlightedRope$fHasDeltaHighlightedRope#$fHasHighlightedRopeHighlightedRope$fToMarkupHighlightedRope $fOrdLocated $fEqLocatedHasHighlightDoc highlightDoc docContentdocCssdocTitledoc$fToMarkupHighlightDoc$fHasHighlightDocHighlightDoc MarkParsingmarkrelease DeltaParsinglineposition slicedWithrend restOfLineslicedcaretingcaretedspanningspannedfixiting$fDeltaParsingIdentityT$fDeltaParsingRWST$fDeltaParsingRWST0$fDeltaParsingWriterT$fDeltaParsingWriterT0$fDeltaParsingReaderT$fDeltaParsingStateT$fDeltaParsingStateT0$fMarkParsingdIdentityT$fMarkParsingdRWST$fMarkParsingdRWST0$fMarkParsingdWriterT$fMarkParsingdWriterT0$fMarkParsingdReaderT$fMarkParsingdStateT$fMarkParsingdStateT0StepStepDoneStepFailStepContParserunparser manyAccumfeedstarve stepResultstepIt stepParser runParser parseFromFileparseFromFileExparseByteString parseString parseTest$fMarkParsingDeltaParser$fDeltaParsingParser$fTokenParsingParser$fCharParsingParser$fLookAheadParsingParser$fErrableParser$fParsingParser$fMonadPlusParser$fMonadFailParser $fMonadParser$fMonoidParser$fSemigroupParser$fAlternativeParser$fApplicativeParser$fFunctorParser $fFunctorStep $fShowStepExprAddLitimportDocumentation parseExprexamples $fShowExprargminargmaxfromLazytoLazytakeLine<$!>base Data.FoldableFoldableData.Traversable Traversable:prettyprinter-ansi-terminal-1.1.1.2-DDJlKRVCiVsHUGfDjNu4eF2Data.Text.Prettyprint.Doc.Render.Terminal.InternalrenderIO underlinedbold AnsiStylechar renderPrettydebold deunderlinecolumnsbytestring-0.10.8.2Data.ByteString.Internal splitRopeAt$comonad-5.0.5-1t7DDbZbcMSAgTS70WFpTSControl.Comonadextract_renderingDelta_renderingLineLen_renderingLineBytes///GHC.ArrArray lens-4.18-HI3642v7827JTf0vyfqsuPControl.Lens.TypePrism*prettyprinter-1.3.0-6qg3eRt5h66FauUzehlm4q"Data.Text.Prettyprint.Doc.InternalDocGHC.Basepureempty Alternative<|>Text.Parser.CombinatorstryStringmemptymanysomeControl.ApplicativeoptionalText.Parser.Tokenoctal hexadecimaldecimalinteger' characterCharident reserveTextreserveliftIdentifierStylestyleHighlightsstyleReservedHighlightstyleHighlight styleReserved styleChars styleLetter styleStart styleName commaSep1commaSepsemiSep1semiSepdotcoloncommabracketsanglesbracesparenssymbolic textSymbolsymbolintegerOrScientificnaturalOrScientific scientificintegerOrDoublenaturalOrDoubledoubleintegernaturalstringLiteral' stringLiteral charLiteral whiteSpace TokenParsingtokensemi highlight someSpacenestingIdentifierStyle _styleName _styleStart _styleLetter_styleReserved_styleHighlight_styleReservedHighlight UnhighlightedrunUnhighlightedUnspaced runUnspacedUnlined runUnlinedText.Parser.Char satisfyRangeoctDigithexDigitdigitletteralphaNumloweruppertabnewlinespacespaces noneOfSetoneOfSetnoneOfoneOf CharParsingtextstringsatisfyanyCharnotCharmanyTillchainr1chainl1chainlchainrcountendBy endByNonEmptyendBy1sepEndBysepEndByNonEmpty sepEndBy1 sepByNonEmptysepBy1sepBy surroundedBybetween skipOptionaloptionchoiceParsingskipManyeof unexpected notFollowedByskipSomeghc-prim GHC.TypesChar