úÎ[+V7      !"#$%&'()*+,-./0123456 Extension of 7/ that allows testing a value for equality with 8. The following law must hold:  mnull == (== mempty) =Class of monoids that can be split into irreducible factors, i.e.-, atoms or primes. The methods of this class  satisfy the following laws:   mconcat . factors == id  factors mempty == [] ) all (\f-> factors f == [f]) (factors m) Y factors == unfoldr splitPrimePrefix == reverse . unfoldr (fmap swap . splitPrimeSuffix) 4 primePrefix == maybe mempty fst . splitPrimePrefix 4 primeSuffix == maybe mempty snd . splitPrimeSuffix % mfoldl f f0 == foldl f f0 . factors % mfoldr f f0 == foldr f f0 . factors G mspan p m == (mconcat l, mconcat r) where (l, r) = span p (factors m) -A minimal instance definition must implement  or . 9Returns a list of all prime factors; inverse of mconcat. The prime prefix, 8 if none. The prime suffix, 8 if none. LSplits the argument into its prime prefix and the remaining suffix. Returns 9 for 8. LSplits the argument into its prime suffix and the remaining prefix. Returns 9 for 8. Like : on the list of primes. Like ; on the list of primes. Like < on the list of primes. A = equivalent. A > equivalent. A ? equivalent. A @ equivalent. A A equivalent. A B equivalent.      qClass of monoids that allow the greatest common denominator to be found for any two given values. The operations " must satisfy the following laws: N commonPrefix (a `mappend` b) (a `mappend` c) == a `mappend` commonPrefix b c N commonSuffix (a `mappend` c) (b `mappend` c) == commonSuffix a b `mappend` c Class of monoids for which the C@ operation can be reverted while satisfying the following laws: * mstripPrefix a (a `mappend` b) == Just b * mstripSuffix b (a `mappend` b) == Just a / maybe b (a `mappend`) (mstripPrefix a b) == b / maybe b (`mappend` a) (mstripSuffix a b) == b )Class of monoids with a right inverse of C , satisfying the following law: * mstripSuffix b (a `mappend` b) == Just a / maybe b (`mappend` a) (mstripSuffix a b) == b (Class of monoids with a left inverse of C , satisfying the following law: * mstripPrefix a (a `mappend` b) == Just b / maybe b (a `mappend`) (mstripPrefix a b) == b    .YThe central parser type. Its first parameter is the input monoid, the second the output. DEFGHIJK*Feeds a chunk of the input to the parser. Signals the end of the input. mExtracts all available parsing results. The first component of the result pair is a list of complete results w together with the unconsumed remainder of the input. If the parsing can continue further, the second component of the ] pair provides the partial result prefix together with the parser for the rest of the input. Like R, but returns only the complete results with the corresponding unconsumed inputs. L8Determines if there are any complete results available. Like ., but returns only the partial result prefix. !CBehaves like the argument parser, but without consuming any input. "+Does not consume any input; succeeds (with 8( result) iff the argument parser fails. MNO#Provides a partial parsing result. #$Like P>, but capable of mapping partial results, being restricted to 7 types only. %SLeft-weighted choice. The right parser is used only if the left one utterly fails. &KJoin operator on parsers of same type, preserving the incremental results. ':A parser that fails on any input and succeeds at its end. (-A parser that accepts any single input atom. )-A parser that accepts a specific input atom. *NA parser that accepts an input atom only if it satisfies the given predicate. +BA parser that consumes and returns the given prefix of the input. ,oA parser accepting the longest sequence of input atoms that match the given predicate; an optimized version of  'many0 . satisfy'. -nA parser accepting the longest non-empty sequence of input atoms that match the given predicate; an optimized  version of 'many1 . satisfy'. .@Accepts the given number of occurrences of the argument parser. /Like Q, but restricted to 7 results. 0-Discards the results of the argument parser. 1'Zero or more argument occurrences like R3, but matches the longest possible input sequence. 2&One or more argument occurrences like S3, but matches the longest possible input sequence. 3CRepeats matching the first argument until the second one succeeds. 4!A parser that accepts all input. 5eParallel parser conjunction: the combined parser keeps accepting input as long as both arguments do. 6LParser sequence that preserves incremental results, otherwise equivalent to T (,) U(Two parsers can be sequentially joined. VThe W and the X instance differ: the former's Y" combinator equals the asymmetric %  choice. Z Usage of [1 destroys the incrementality of its left argument's parsing results, but \ is safe to use. ]The ^! choice combinator is symmetric. _The `W combinator requires its both arguments to provide complete parsing results, takeWhile a and b preserve  the incremental results. c Usage of PD destroys the incrementality of parsing results, if you need it use $ instead.  !"#$%&'()*+,-./0123456 '()*4+,-.0/123$&%!"56# !"#$%&'()*+,-./0123456d      !"#$%&'()*+,-./0123456789:;<=><=?<@A<BC<DE<BF<BG<BH<DI<BJ<B1<BK<=LMNOPQRSTUVWX<DY<Z[<Z\<Z]<Z^_`<ab<Zc<ade<Df<Dgh<Zij<Zk<Zl<Zmnoincremental-parser-0.1Data.Monoid.NullData.Monoid.FactorialData.Monoid.Cancellative"Text.ParserCombinators.Incremental MonoidNullmnullFactorialMonoidfactors primePrefix primeSuffixsplitPrimePrefixsplitPrimeSuffixmfoldlmfoldrmspanmbreakmlengthmmapmreverse mtakeWhile mdropWhile GCDMonoidCancellativeMonoidRightGCDMonoid commonSuffix LeftGCDMonoid commonPrefixRightCancellativeMonoid mstripSuffixLeftCancellativeMonoid mstripPrefixParserfeedfeedEofresultscompleteResults resultPrefix lookAhead notFollowedByshowWithmapIncremental<<|>><eofanyTokentokensatisfystring takeWhile takeWhile1countoptionskipmany0many1manyTill acceptAllandandThenbase Data.MonoidMonoidmempty Data.MaybeNothingGHC.ListfoldlGHC.Basefoldrspanbreaklengthmapreverse dropWhilemappend ApplyInputApplyMoreCommitedLeftChoiceChoice ResultPartResultFailure hasResult lookAheadIntolookAheadNotInto resultPartfmapControl.ApplicativeoptionalmanysomeliftA2$fMonoidParser$fMonadPlusParser Control.Monad MonadPlus Alternativemplus $fMonadParser>>=>>$fAlternativeParser<|>$fApplicativeParser<*>*><*$fFunctorParser