!eF      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn o p q r s t u v w x y z { | } ~                                              (c) Edward Kmett 2013-2015BSD3ekmett@gmail.com experimental non-portableSafe(C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableSafe16) trifecta;Since there are multiple ways to be at a certain location, 3 captures all these alternatives as a single type.trifecta +( number of characters , number of bytes ) trifecta _( number of characters before the tab , number of characters after the tab , number of bytes ) trifecta ( number of newlines contained , number of characters since the last newline , number of bytes , number of bytes since the last newline ) trifecta ( 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 ) trifecta@Retrieve the character offset within the current line from this . trifecta;Retrieve the byte offset within the current line from this . trifecta.Increment a column number to the next tabstop. trifecta Rewind a  to the beginning of the line.trifecta!Should we show two things with a  on the same line? near (Columns 0 0) (Columns 5 5)True$near (Lines 1 0 1 0) (Lines 2 4 4 2)Falsetrifecta Example: file.txt:12:34   8Edward Kmett 2011-2015 Johan Tibell 2011BSD3ekmett@gmail.com experimentalunknownNoneDQV6W trifectaSmart constructortrifectaSmart constructor%trifectaCreate a new mutable array of specified size, in the specified state thread, with each element containing the specified initial value.1trifectaEUnsafely copy the elements of an array. Array bounds are not checked.2trifectaEUnsafely copy the elements of an array. Array bounds are not checked.3trifectaO(n)T Insert an element at the given position in this array, increasing its size by one.4trifectaO(n)8 Update the element at the given position in this array.8trifectaO(n)T Delete an element at the given position in this array, decreasing its size by one.:trifectaStrict version of 9.!"#$%&'()*+,-./0123456789:;<"!%&'(#$)*+,-438./0125679:;< (C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableSafe964(C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableSafe 16;=>?FTV$AtrifectaData of a certain lengthBtrifecta#Absence of data of a certain lengthCtrifectaConstruct a single @ out of a .Etrifecta Construct a > out of a single  strand.Gtrifecta"Grab the entire rest of the input >f, starting at an initial offset, or return a default if we re already at or beyond the end. Also see H.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  offset from the beginning.Htrifecta;Grab the rest of the line at a certain offset in the input >K, or return a default if there is no newline left in the input. Also see G.grabLine (delta ("Hello " :: ByteString)) (ropeBS "Hello" <> ropeBS " World\nLorem") Nothing (\x y -> Just (x, Strict.toString y))Just (Columns 6 6,"World\n")GtrifectaInitial 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 endHtrifectaInitial 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 >?@ABCDEFGH >?DE@ABCFGH(C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableNone16;=>?yZtrifectaA Z3 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 f with a suggestion.Vplain (pretty (addFixit (Columns 35 35) (Columns 38 38) "Fix this!" exampleRendering)).int main(int argc, char ** argv) { int; }<EOF>& ~~~, Fix this!`trifectaf where the error occurredatrifectaReplacement suggestionbtrifecta+Annotate an arbitrary piece of data with a f., typically its corresponding input location.ftrifectaA f' marks a range of input characters. If l is a point, then f is a line.Iplain (pretty (addSpan (Columns 35 35) (Columns 38 38) exampleRendering)).int main(int argc, char ** argv) { int; }<EOF>& ~~~ltrifectaA l* marks a point in the input with a simple ^ character.:plain (pretty (addCaret (Columns 35 35) exampleRendering)).int main(int argc, char ** argv) { int; }<EOF>$ ^qtrifecta 8( Number of (padded) columns , number of bytes , line ) {trifectaIs the Z empty?nullRendering emptyRenderingTruenullRendering exampleRenderingFalse|trifecta The empty Z , which contains nothing at all.show (pretty emptyRendering)""~trifectacreate a drawing surfacetrifecta,ANSI terminal style for rendering the caret.trifecta*Render a caret at a certain position in a Z.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 on}trifecta 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 to3Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~3Z[tuvwxyz{|pq~rsnolmjkhifgdebc^_`a\]}(c) Edward Kmett 2011-2015BSD3ekmett@gmail.com experimental non-portableNone345;<=>?AQVRtrifectaThis 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 Z! of auxiliary information and an  into a ), ready to be prettyprinted to the user.trifecta Fold over a trifectaThe  for the  constructor of trifectaThe  for the  constructor of (c) Edward Kmett 2011-2015BSD3ekmett@gmail.com experimental non-portableNone;<=>?AwtrifectaThis class is a refinement of  f that adds the ability to mark your position in the input and return there for further parsing later. trifectaYmark the current location so it can be used in constructing a span, or for later seeking trifecta!Seek a previously marked location trifecta0This class provides parsers with easy access to:<1) the current line contents. 2) the current position as a . 3) the ability to use  on any parser. trifectaJRetrieve the contents of the current line (from the beginning of the line) trifecta#Retrieve the current position as a .trifectaGRun a parser, grabbing all of the text between its start and end pointstrifecta Retrieve a Z> of the current line noting this position, but not placing a l there.trifecta&Grab the remainder of the current linetrifectakRun a parser, grabbing all of the text between its start and end points and discarding the original resulttrifectaGrab a l" pointing to the current location.trifectaParse a h result. Pointing the l to where you start.trifecta+Discard the result of a parse, returning a f0 from where we start to where it ended parsing.trifectaParse a b result. The f3 starts here and runs to the last position parsed.trifecta Grab a fixit.          A(c) Edward Kmett 2011-2015 (c) Ross Paterson 2008 BSD-styleekmett@gmail.com experimental<non-portable (MPTCs, type families, functional dependencies)Safe ;=>?FTn '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.1trifectaO(n)). Add a delta to each interval in the map2trifectaO(1)$. Interval map with a single entry.3trifectaO(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.4trifecta O(k log (n/k))L. All intervals that contain the given interval, in lexicographical order.5trifecta O(k log (n/k))I. All intervals that contain the given point, in lexicographical order.6trifecta O(k log (n/k))S. All intervals that intersect with the given interval, in lexicographical order.Ktrifecta 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.'()*,+-.0/1234567-.0/'()235641*,+7(C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableNoneTtrifectaA T is a > with an associated ' full of highlighted regions.Vtrifecta Convert a  into a coloration on a .Wtrifecta;Represents a source file like an HsColour rendered documentktrifecta-Generate an HTML document from a title and a T.TUVWXYZ[\fghijkTUYZ[\VWXfghijk5 (C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableSafe >?DFT ntrifectan is an  0https://wiki.haskell.org/Enumerator_and_iterateeIteratee# that can produce partial results.n r a consumes a feed of rs and produces a+s on the way. New values can be fed using q<, 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)5otrifecta+Final result, rest of the feed is discardedptrifecta8Intermediate result, consumed values produce new resultsqtrifectaFeed a value to n,, obtaining a new (partial or final) result.rtrifecta-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)11strifectaNConsumes input and produces partial results until a condition is met. Unlike rP, 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) 11ttrifecta>The generalized fold (Bhm-Berarducci decoding) over 'It r a'.t satisfies the property: foldIt Pure It = idutrifectaScott 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.u 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] -> bvtrifectaSGiven 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"wtrifecta: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"xtrifecta$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"ytrifectan is a cofree comonadrtrifectaInitial resulttrifectaProduce a result if possiblestrifectaInitial resulttrifecta!Produce a partial or final result nopqrstuvwx noprsqtuvwx (c) Edward Kmett 2011-2015BSD3ekmett@gmail.com experimental non-portableNone345;<=>?AQV# trifectaA 1 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 cometrifecta&Parsing is done and has converted the > to a final resulttrifecta Parsing the > has failed with an errortrifectaThe >3 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.trifectaThe 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 analysis 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).trifecta Feed some additional input to a # to continue parsing a bit further.trifecta\Assume all possible input has been given to the parser, execute it to yield a final result.trifectaIncremental parsing. A & can be supplied with new input using  , the final  is obtained using .trifectaRun a # on input that can be reduced to a >, e.g. , or $. See also the monomorphic versions  and .trifecta( 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 atrifecta( 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)trifectaFully parse a  to a .parseByteString p delta i runs a parser p on i.trifectaFully parse a  to a .parseByteString p delta i runs a parser p on i.trifecta"Starting cursor position. Usually  for the beginning of the file.trifecta"Starting cursor position. Usually  for the beginning of the file.trifecta"Starting cursor position. Usually  for the beginning of the file.trifecta"Starting cursor position. Usually  for the beginning of the file.(C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett <ekmett@gmail.com> experimental non-portableNone&C      !"#$%&'()*+,-./0123456789:;<=>>?@ABCDEFGHZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     TUVWXYZ[\fghijk NoneEtrifecta^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 $, 4!, 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))" B(interactive):1:8: error: expected: ")" (1 + 2 + 3))<EOF> ^@ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQQRRSTUVWXYZ[\]^_`abcdefghijkklmmnopqrsttuvwxyyz{|}~      !"#$%&'()*+,-./011234355678;F9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYYZ[[\]^_`abcdefghijklmnop q r q s t u v w x y z { | } ~                                                    5{I:       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL!trifecta-2-3LqJ6YGQno0FNVjGdpeVXYText.Trifecta.HighlightText.Trifecta.DeltaText.Trifecta.Util.ArrayText.Trifecta.RopeText.Trifecta.RenderingText.Trifecta.ResultText.Trifecta.CombinatorsText.Trifecta.Util.IntervalMapText.Trifecta.Util.ItText.Trifecta.ParserText.Trifecta.TutorialText.Trifecta.InstancesText.Trifecta.Util.Combinators ByteStringreadFile Text.Trifecta%parsers-0.12.9-1E6TCDZX3l13GJ9dHyt7qTText.Parser.Token.Highlight HighlightHasDeltadeltaDeltaColumnsTabLinesDirectedHasBytesbytescolumn columnBytenextTabrewindnear$fHasBytesFingerTree$fHasBytesByteString$fSemigroupDelta $fMonoidDelta$fHashableDelta$fHasBytesDelta $fPrettyDelta $fOrdDelta $fEqDelta$fHasDeltaFingerTree$fHasDeltaByteString$fHasDeltaWord8$fHasDeltaChar$fHasDeltaDelta$fHasDeltaEither $fShowDelta $fDataDelta$fGenericDeltaMArrayArraylengthlengthMnewnew_empty singletonreadwriteindexindex_indexM_ unsafeFreezerunrun2copycopyMinsertupdatefoldl'foldrthawdeletemapmap'traversefilter $fNFDataArrayRopeStrandSkippingstrandroperopeBSstrandsgrabRestgrabLine$fHasBytesStrand$fHasDeltaStrand$fHashableStrand$fMeasuredDeltaStrand$fReducer[]Rope$fReducerByteStringRope$fReducerStrandRope$fReducerRopeRope$fSemigroupRope $fMonoidRope$fMeasuredDeltaRope$fHasDeltaRope$fHasBytesRope $fShowStrand $fDataStrand$fGenericStrand $fShowRope RenderingdrawFixit _fixitSpan_fixitReplacementSpanned:~HasSpanspanSpanCareted:^HasCaretcaretCaretRendered:@Sourcesource Renderablerender HasRendering renderingrenderingDelta renderingLinerenderingLineBytesrenderingLineLenrenderingOverlays nullRenderingemptyRenderingifNearrendered.# caretEffects drawCaretaddCaretrenderingCaret spanEffectsdrawSpanaddSpan drawFixitaddFixit$fPrettyRendering$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$fPrettyResult$fAsResultResultResultab $fShowResult$fFunctorResult$fFoldableResult$fTraversableResult MarkParsingmarkrelease DeltaParsinglineposition slicedWithrend restOfLineslicedcaretingcaretedspanningspannedfixiting$fDeltaParsingIdentityT$fDeltaParsingRWST$fDeltaParsingRWST0$fDeltaParsingWriterT$fDeltaParsingWriterT0$fDeltaParsingReaderT$fDeltaParsingStateT$fDeltaParsingStateT0$fMarkParsingdIdentityT$fMarkParsingdRWST$fMarkParsingdRWST0$fMarkParsingdWriterT$fMarkParsingdWriterT0$fMarkParsingdReaderT$fMarkParsingdStateT$fMarkParsingdStateT0 IntervalMaprunIntervalMap IntInterval NoIntervalIntervallowhighoffset 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$fShowIntervalHighlightedRope withHighlight HighlightDocHasHighlightedRopehighlightedRope ropeContentropeHighlights$fPrettyHighlightedRope$fMonoidHighlightedRope$fSemigroupHighlightedRope$fHasBytesHighlightedRope$fHasDeltaHighlightedRope#$fHasHighlightedRopeHighlightedRope$fToMarkupHighlightedRope $fOrdLocated $fEqLocatedHasHighlightDoc highlightDoc docContentdocCssdocTitledoc$fToMarkupHighlightDoc$fHasHighlightDocHighlightDocItPure simplifyItneedItwantItfoldItrunItfillItrewindItsliceIt $fComonadIt$fComonadApplyIt $fMonadIt$fApplicativeIt$fProfunctorIt $fFunctorIt$fShowItStepStepDoneStepFailStepContParserunparser 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 $fShowExprarraymarrayargminargmaxfromLazytoLazytakeLine<$!>bytestring-0.10.8.2Data.ByteString.Internal splitRopeAt_renderingDelta_renderingLineLen_renderingLineBytes///baseGHC.Arr lens-4.17-4hErJ42O7uV8vzBxecIjOxControl.Lens.TypePrism-ansi-wl-pprint-0.6.8.2-6AdIxh22sHDEM4okAgCrQl%Text.PrettyPrint.ANSI.Leijen.InternalDoc Data.FoldableFoldableData.Traversable Traversable$comonad-5.0.4-E437j0xZa4yEk94g9329dNControl.ComonadextractData.ByteString.LazyGHC.Basepure Alternative<|>Text.Parser.CombinatorstryStringmemptymanysomeControl.ApplicativeoptionalText.Parser.Tokenoctal hexadecimaldecimalinteger' characterCharident reserveTextreserveliftIdentifierStylestyleHighlightsstyleReservedHighlightstyleHighlight styleReserved styleChars styleLetter styleStart styleName commaSep1commaSepsemiSep1semiSepdotcoloncommabracketsanglesbracesparenssymbolic textSymbolsymbolintegerOrScientificnaturalOrScientific scientificintegerOrDoublenaturalOrDoubledoubleintegernaturalstringLiteral' stringLiteral charLiteral whiteSpace TokenParsingseminestingtoken highlight someSpaceIdentifierStyle _styleName _styleStart _styleLetter_styleReserved_styleHighlight_styleReservedHighlight UnhighlightedrunUnhighlightedUnspaced runUnspacedUnlined runUnlinedText.Parser.Char satisfyRangeoctDigithexDigitdigitletteralphaNumloweruppertabnewlinespacespaces noneOfSetoneOfSetnoneOfoneOf CharParsingtextstringcharsatisfyanyCharnotCharmanyTillchainr1chainl1chainlchainrcountendBy endByNonEmptyendBy1sepEndBysepEndByNonEmpty sepEndBy1 sepByNonEmptysepBy1sepBy surroundedBybetween skipOptionaloptionchoiceParsingskipManyeof unexpected notFollowedByskipSomeghc-prim GHC.TypesChar