ݜj      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde f g h i  Trustworthy Subclass of j? for types whose values have no inverse, with the exception of kE. More formally, the class instances must satisfy the following law:#null (x <> y) == (null x && null y) Extension of j/ that allows testing a value for equality with k. The following law must hold:null x == (x == mempty)@Furthermore, the performance of this method should be constant, i.e.,, independent of the length of its argument.,lmnopqrstuvwxyz{|}~+lmnopqrstuvwxyz{|}~ TrustworthyA subclass of - whose instances satisfy this additional law: *factors (a <> b) == factors a <> factors b5Class of monoids that can be split into irreducible (i.e., atomic or prime)  in a unique way. Factors of a ! are literally its prime factors:9factors (Product 12) == [Product 2, Product 2, Product 3]Factors of a list are not/ its elements but all its single-item sublists: factors "abc" == ["a", "b", "c"]5The methods of this class satisfy the following laws: mconcat . factors == id null == List.null . factors List.all (\prime-> factors prime == [prime]) . factors factors == unfoldr splitPrimePrefix == List.reverse . unfoldr (fmap swap . splitPrimeSuffix) reverse == mconcat . List.reverse . factors primePrefix == maybe mempty fst . splitPrimePrefix primeSuffix == maybe mempty snd . splitPrimeSuffix inits == List.map mconcat . List.tails . factors tails == List.map mconcat . List.tails . factors foldl f a == List.foldl f a . factors foldl' f a == List.foldl' f a . factors foldr f a == List.foldr f a . factors span p m == (mconcat l, mconcat r) where (l, r) = List.span p (factors m) List.all (List.all (not . pred) . factors) . split pred mconcat . intersperse prime . split (== prime) == id splitAt i m == (mconcat l, mconcat r) where (l, r) = List.splitAt i (factors m) spanMaybe () (const $ bool Nothing (Maybe ()) . p) m == (takeWhile p m, dropWhile p m, ()) spanMaybe s0 (\s m-> Just $ f s m) m0 == (m0, mempty, foldl f s0 m0) let (prefix, suffix, s') = spanMaybe s f m foldMaybe = foldl g (Just s) g s m = s >>= flip f m in all ((Nothing ==) . foldMaybe) (inits prefix) && prefix == last (filter (isJust . foldMaybe) $ inits m) && Just s' == foldMaybe prefix && m == prefix <> suffix-A minimal instance definition must implement  or U. Other methods are provided and should be implemented only for performance reasons.8Returns a list of all prime factors; inverse of mconcat.The prime prefix, k if none.The prime suffix, k if none.LSplits the argument into its prime prefix and the remaining suffix. Returns  for k. LSplits the argument into its prime suffix and the remaining prefix. Returns  for k. 2Returns the list of all prefixes of the argument, k first. 2Returns the list of all suffixes of the argument, k last. Like  from  Data.List on the list of primes. Like  from  Data.List on the list of primes.Like  from  Data.List on the list of primes.The  of the list of primes. Generalizes  from  Data.FoldableV, except the function arguments are prime factors rather than the structure elements.Like  from  Data.List on the list of primes.Equivalent to  from  Data.List.Splits the monoid into components delimited by prime separators satisfying the given predicate. The primes satisfying the predicate are not a part of the result.Equivalent to  from  Data.List.Equivalent to  from  Data.List.A stateful variant of B, threading the result of the test function as long as it returns .Strict version of .Like  from  Data.List on the list of primes.Equivalent to  from  Data.List.Equivalent to  from  Data.List.Equivalent to  from  Data.List.A  equivalent.A  equivalent.7      Trustworthy Class of monoids capable of finding the equivalent of greatest common divisor on the right side of two monoidal values. The methods' complexity must be no worse than linear in the length of the common suffix. The following laws must be respected: stripCommonSuffix a b == (a', b', s) where s = commonSuffix a b Just a' = stripSuffix p a Just b' = stripSuffix p b s == commonSuffix a b && a' <> s == a && b' <> s == b where (a', b', s) = stripCommonSuffix a b!Class of monoids capable of finding the equivalent of greatest common divisor on the left side of two monoidal values. The methods' complexity should be no worse than linear in the length of the common prefix. The following laws must be respected: stripCommonPrefix a b == (p, a', b') where p = commonPrefix a b Just a' = stripPrefix p a Just b' = stripPrefix p b p == commonPrefix a b && p <> a' == a && p <> b' == b where (p, a', b') = stripCommonPrefix a b$ Subclass of ) where + is a complete inverse of <>+, satisfying the following additional law:  stripSuffix b (a <> b) == Just a% Subclass of ) where + is a complete inverse of <>+, satisfying the following additional law:  stripPrefix a (a <> b) == Just b&)Class of monoids with a right inverse of , satisfying the following law: hisSuffixOf a b == isJust (stripSuffix a b) maybe b (<> a) (stripSuffix a b) == b b `isSuffixOf` (a <> b):| Every instance definition has to implement at least the (] method. Its complexity should be no worse than linear in the length of the suffix argument.)(Class of monoids with a left inverse of , satisfying the following law: hisPrefixOf a b == isJust (stripPrefix a b) maybe b (a <>) (stripPrefix a b) == b a `isPrefixOf` (a <> b):| Every instance definition has to implement at least the +] method. Its complexity should be no worse than linear in the length of the prefix argument.,Class of Abelian monoids that allow the greatest common denominator to be found for any two given values. The operations must satisfy the following laws: kgcd a b == commonPrefix a b == commonSuffix a b Just a' = a </> p && Just b' = b </> p where p = gcd a bIf a , happens to also be a .4, it should additionally satisfy the following laws: Kgcd (a <> b) (a <> c) == a <> gcd b c gcd (a <> c) (b <> c) == gcd a b <> c. Subclass of / where 0% is a complete inverse of the Monoid <>L operation. The class instances must satisfy the following additional laws: 1(a <> b) </> a == Just b (a <> b) </> b == Just a/?Class of Abelian monoids with a partial inverse for the Monoid <>" operation. The inverse operation 0" must satisfy the following laws: ;maybe a (b <>) (a </> b) == a maybe a (<> b) (a </> b) == a1[Class of all Abelian ({i.e.}, commutative) monoids that satisfy the commutativity property: a <> b == b <> a~ !"#$%&'()*+,-./01      !"#$%&'()*+ !"#$%&'()*+,-./011/0.,-)*+&'(%$!"# t !"#$%&'()*+,-./01      !"#$%&'()*+0 Trustworthy24!2The 2 class is an extension of } specialized for monoids that can contain characters. Its methods are generally equivalent to their namesake functions from  Data.List and  Data.Text', and they satisfy the following laws: zunfoldr splitCharacterPrefix . fromString == id splitCharacterPrefix . primePrefix == fmap (\(c, t)-> (c, mempty)) . splitCharacterPrefix map f . fromString == fromString . List.map f concatMap (fromString . f) . fromString == fromString . List.concatMap f foldl ft fc a . fromString == List.foldl fc a foldr ft fc a . fromString == List.foldr fc a foldl' ft fc a . fromString == List.foldl' fc a scanl f c . fromString == fromString . List.scanl f c scanr f c . fromString == fromString . List.scanr f c mapAccumL f a . fromString == fmap fromString . List.mapAccumL f a mapAccumL f a . fromString == fmap fromString . List.mapAccumL f a takeWhile pt pc . fromString == fromString . takeWhile pc dropWhile pt pc . fromString == fromString . dropWhile pc mconcat . intersperse (singleton c) . split (== c) == id find p . fromString == List.find p elem c . fromString == List.elem cA 2r may contain non-character data insterspersed between its characters. Every class method that returns a modified 2D instance generally preserves this non-character data. Methods like = can access both the non-character and character data and expect two arguments for the two purposes. For each of these methods there is also a simplified version with underscore in name (like O') that ignores the non-character data.0All of the following expressions are identities: 3map id concatMap singleton foldl (<>) (\a c-> a <> singleton c) mempty foldr (<>) ((<>) . singleton) mempty foldl' (<>) (\a c-> a <> singleton c) mempty scanl1 (const id) scanr1 const uncurry (mapAccumL (,)) uncurry (mapAccumR (,)) takeWhile (const True) (const True) dropWhile (const False) (const False)-A minimal instance definition must implement 5.3(Contructs a new data type instance Like , , but from a - input instead of .. $fromText == fromString . Text.unpack45Creates a prime monoid containing a single character. singleton c == fromString [c]5Specialized version of . Every prime factor of a TextualC monoid must consist of a single character or no character at all.6pExtracts a single character that prefixes the monoid, if the monoid begins with a character. Otherwise returns . 2characterPrefix == fmap fst . splitCharacterPrefix7Equivalent to / from  Data.List with a  Char -> Char, function. Preserves all non-character data. "map f == concatMap (singleton . f)8Equivalent to 0 from  Data.List with a Char -> String- function. Preserves all non-character data.9Equivalent to 1 from  Data.List!. Ignores all non-character data.:Equivalent to 2 from  Data.List!. Ignores all non-character data.;tThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent to  from  Data.List.<Strict version of ;.=The first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent to 'List.foldl\'' from  Data.List.>Equivalent to 3 from  Data.List when applied to a .', but preserves all non-character data.?Equivalent to 4 from  Data.List when applied to a .', but preserves all non-character data. (scanl f c == scanl1 f . (singleton c <>)@Equivalent to 5 from  Data.List when applied to a .', but preserves all non-character data.AEquivalent to 6 from  Data.List when applied to a .', but preserves all non-character data. (scanr f c == scanr1 f . (<> singleton c)BEquivalent to 7 from  Data.List when applied to a .(, but preserves all non-character data.CEquivalent to 8 from  Data.List when applied to a .(, but preserves all non-character data.DjThe first predicate tests the non-character data, the second one the characters. Otherwise equivalent to  from  Data.List when applied to a ..EjThe first predicate tests the non-character data, the second one the characters. Otherwise equivalent to  from  Data.List when applied to a ..F<'break pt pc' is equivalent to |span (not . pt) (not . pc)|.GI'span pt pc t' is equivalent to |(takeWhile pt pc t, dropWhile pt pc t)|.HA stateful variant of GB, threading the result of the test function as long as it returns .IStrict version of H.JSplits the monoid into components delimited by character separators satisfying the given predicate. The characters satisfying the predicate are not a part of the result. <split p == Factorial.split (maybe False p . characterPrefix)KLike 9 from  Data.List when applied to a .. Ignores non-character data.LLike : from  Data.List when applied to a .. Ignores non-character data.M foldl_ = foldl constP takeWhile_ = takeWhile . constQ dropWhile_ = dropWhile . constR break_ = break . constS span_ = span . constT )spanMaybe_ s = spanMaybe s (const . Just)/23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU;<=>?@ABCDE$23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU$23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU 2#3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU;<=>?@ABCDENoneX Takes a raw F chunk and returns a pair of V decoding the prefix of the chunk and the remaining suffix that is either null or contains the incomplete last character of the chunk.VWXGHIJKLMNOPQRSTUVWXYZVWXVWXVWXGHIJKLMNOPQRSTUVWXYZ Safe-InferredYY a is a newtype wrapper around [ a. The behaviour of the Y aH instances of monoid subclasses is identical to the behaviour of their a instances, up to the \ isomorphism.The only purpose of Yw then is to change the performance characteristics of various operations. Most importantly, injecting a monoid into a Y has the effect of making  a constant-time operation.Y]Z[^_`abcdefghijklYZ[YZ[ZY]Z[^_`abcdefghijkl Safe-Inferred\\ a is a wrapper around the  a that memoizes the monoid's N so it becomes a constant-time operation. The parameter is restricted to the  class, which guarantees that  (a <> b) ==  a +  b.^ Create a new \ value.\mn]^opqrstuvwxyz\]^\]^]\mn]^opqrstuvwxyz Safe-Inferred`the current line{the current offsetdthe current column4_|}`~a{bcd_`abcda_`bc`d*_|}`~a{bcd  Safe-Inferredee a b is a wrapper around the j b that carries the state a along. The state type a must be a monoid as well if e is to be of any use. In the  and 2 class instances, the monoid b has the priority and the state a is left for the end.efghiefghiefghiefghi     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ !KLMNOPQRSTUVVWXYZ[Y\]^_Y`a b b Y c defgefhijklmnopqrstuvwxyz{|}~efeeeeeeeeee"e#e$e%e&e'ef      e!"#$%e&eAeBeCeDeEeFeGeHeIeJeKeL'()*+,-./0123456789:;<=>?@ABCDEFGHIJKeLMXNOPQRSTUVWXYZ[\[]^_`abcdefghij]klm_nopqrstuvwxyz{|}~             monoid-subclasses-0.4Data.Monoid.NullData.Monoid.FactorialData.Monoid.CancellativeData.Monoid.Textual%Data.Monoid.Instances.ByteString.UTF8Data.Monoid.Instances.ConcatData.Monoid.Instances.Measured Data.Monoid.Instances.PositionedData.Monoid.Instances.StatefulPositiveMonoid MonoidNullnullStableFactorialMonoidFactorialMonoidfactors primePrefix primeSuffixsplitPrimePrefixsplitPrimeSuffixinitstailsfoldlfoldl'foldrlengthfoldMapspanbreaksplit takeWhile dropWhile spanMaybe spanMaybe'splitAtdroptakereversemapMmapM_RightGCDMonoid commonSuffixstripCommonSuffix LeftGCDMonoid commonPrefixstripCommonPrefixRightCancellativeMonoidLeftCancellativeMonoidRightReductiveMonoid isSuffixOf stripSuffixLeftReductiveMonoid isPrefixOf stripPrefix GCDMonoidgcdCancellativeMonoidReductiveMonoidCommutativeMonoid TextualMonoidfromText singletonsplitCharacterPrefixcharacterPrefixmap concatMapanyallscanlscanl1scanrscanr1 mapAccumL mapAccumRfindelemfoldl_foldl_'foldr_ takeWhile_ dropWhile_break_span_ spanMaybe_ spanMaybe_'ByteStringUTF8decodeConcatextract concatenateMeasuredmeasureLinePositionedlineOffsetPositionedpositioncolumnStatefulstatesetStatebase Data.MonoidMonoidmempty$fPositiveMonoidVector$fPositiveMonoidSet$fPositiveMonoidSeq$fPositiveMonoidIntSet$fPositiveMonoidIntMap$fPositiveMonoidMap$fPositiveMonoid[]$fPositiveMonoidDual$fPositiveMonoidLast$fPositiveMonoidFirst$fPositiveMonoidMaybe$fPositiveMonoidText$fPositiveMonoidText0$fPositiveMonoidByteString$fPositiveMonoidByteString0$fPositiveMonoidAny$fPositiveMonoidAll$fPositiveMonoidOrdering$fPositiveMonoid()$fMonoidNullVector$fMonoidNullSet$fMonoidNullSeq$fMonoidNullIntSet$fMonoidNullIntMap$fMonoidNullMap$fMonoidNullText$fMonoidNullText0$fMonoidNullByteString$fMonoidNullByteString0$fMonoidNull[]$fMonoidNull(,)$fMonoidNullMaybe$fMonoidNullProduct$fMonoidNullSum$fMonoidNullDual$fMonoidNullLast$fMonoidNullFirst$fMonoidNullAny$fMonoidNullAll$fMonoidNullOrdering$fMonoidNull()Product Data.MaybeNothingGHC.List Data.ListGHC.BaseJust Control.MonadfromFstfromSnd$fStableFactorialMonoidVector$fStableFactorialMonoidSeq$fStableFactorialMonoidText$fStableFactorialMonoidText0!$fStableFactorialMonoidByteString"$fStableFactorialMonoidByteString0$fStableFactorialMonoid[]$fStableFactorialMonoidDual$fStableFactorialMonoid()$fFactorialMonoidVector$fFactorialMonoidSet$fFactorialMonoidSeq$fFactorialMonoidIntSet$fFactorialMonoidIntMap$fFactorialMonoidMap$fFactorialMonoidText$fFactorialMonoidText0$fFactorialMonoidByteString$fFactorialMonoidByteString0$fFactorialMonoid[]$fFactorialMonoid(,)$fFactorialMonoidMaybe$fFactorialMonoidProduct$fFactorialMonoidSum$fFactorialMonoidDual$fFactorialMonoid()mappend$fLeftGCDMonoidText$fRightCancellativeMonoidText$fLeftCancellativeMonoidText$fRightReductiveMonoidText$fLeftReductiveMonoidText$fLeftGCDMonoidText0$fRightCancellativeMonoidText0$fLeftCancellativeMonoidText0$fRightReductiveMonoidText0$fLeftReductiveMonoidText0$fRightGCDMonoidByteString$fLeftGCDMonoidByteString#$fRightCancellativeMonoidByteString"$fLeftCancellativeMonoidByteString $fRightReductiveMonoidByteString$fLeftReductiveMonoidByteString$fRightGCDMonoidByteString0$fLeftGCDMonoidByteString0$$fRightCancellativeMonoidByteString0#$fLeftCancellativeMonoidByteString0!$fRightReductiveMonoidByteString0 $fLeftReductiveMonoidByteString0$fRightGCDMonoidVector$fLeftGCDMonoidVector$fRightCancellativeMonoidVector$fLeftCancellativeMonoidVector$fRightReductiveMonoidVector$fLeftReductiveMonoidVector$fRightGCDMonoidSeq$fLeftGCDMonoidSeq$fRightCancellativeMonoidSeq$fLeftCancellativeMonoidSeq$fRightReductiveMonoidSeq$fLeftReductiveMonoidSeq$fLeftGCDMonoid[]$fLeftCancellativeMonoid[]$fLeftReductiveMonoid[]$fLeftGCDMonoidIntMap$fLeftReductiveMonoidIntMap$fLeftGCDMonoidMap$fLeftReductiveMonoidMap$fGCDMonoidIntSet$fRightGCDMonoidIntSet$fLeftGCDMonoidIntSet$fReductiveMonoidIntSet$fRightReductiveMonoidIntSet$fLeftReductiveMonoidIntSet$fCommutativeMonoidIntSet$fGCDMonoidSet$fRightGCDMonoidSet$fLeftGCDMonoidSet$fReductiveMonoidSet$fRightReductiveMonoidSet$fLeftReductiveMonoidSet$fCommutativeMonoidSet$fRightGCDMonoidMaybe$fRightReductiveMonoidMaybe$fLeftGCDMonoidMaybe$fLeftReductiveMonoidMaybe$fRightGCDMonoid(,)$fLeftGCDMonoid(,)$fRightCancellativeMonoid(,)$fLeftCancellativeMonoid(,)$fRightReductiveMonoid(,)$fLeftReductiveMonoid(,)$fGCDMonoid(,)$fCancellativeMonoid(,)$fReductiveMonoid(,)$fCommutativeMonoid(,)$fRightGCDMonoidProduct$fLeftGCDMonoidProduct$fRightReductiveMonoidProduct$fLeftReductiveMonoidProduct$fGCDMonoidProduct$fReductiveMonoidProduct$fCommutativeMonoidProduct$fRightGCDMonoidSum$fLeftGCDMonoidSum$fRightCancellativeMonoidSum$fLeftCancellativeMonoidSum$fRightReductiveMonoidSum$fLeftReductiveMonoidSum$fGCDMonoidSum$fCancellativeMonoidSum$fReductiveMonoidSum$fCommutativeMonoidSum$fLeftGCDMonoidDual$fRightGCDMonoidDual$fLeftCancellativeMonoidDual$fRightCancellativeMonoidDual$fLeftReductiveMonoidDual$fRightReductiveMonoidDual$fGCDMonoidDual$fCancellativeMonoidDual$fReductiveMonoidDual$fCommutativeMonoidDual$fRightGCDMonoid()$fLeftGCDMonoid()$fRightCancellativeMonoid()$fLeftCancellativeMonoid()$fRightReductiveMonoid()$fLeftReductiveMonoid() $fGCDMonoid()$fCancellativeMonoid()$fReductiveMonoid()$fCommutativeMonoid() Data.String fromString text-1.2.0.3Data.Text.InternalTextString foldlChars foldlOther foldrChars foldrOther$fTextualMonoidVector$fIsStringVector$fTextualMonoidSeq $fIsStringSeq$fTextualMonoidText$fTextualMonoidText0$fTextualMonoid[]bytestring-0.10.4.0Data.ByteString.Internal ByteStringreverseBytesToChar bytesToCharwrapPair wrapTriplefromChartoChar groupASCII headIndexbyteStartsCharactercharStartIndex$fTextualMonoidByteStringUTF8$fFactorialMonoidByteStringUTF8$fPositiveMonoidByteStringUTF8$fIsStringByteStringUTF8$fShowByteStringUTF8$fLeftGCDMonoidByteStringUTF8&$fLeftCancellativeMonoidByteStringUTF8#$fLeftReductiveMonoidByteStringUTF8$fMonoidNullByteStringUTF8$fMonoidByteStringUTF8containers-0.5.5.1 Data.SequenceSeqControl.ApplicativepureinjectSingleton$fTextualMonoidConcat$fIsStringConcat$fFactorialMonoidConcat$fRightGCDMonoidConcat$fLeftGCDMonoidConcat$fRightReductiveMonoidConcat$fLeftReductiveMonoidConcat$fPositiveMonoidConcat$fMonoidNullConcat$fMonoidConcat$fApplicativeConcat$fFunctorConcat $fOrdConcat $fEqConcatmeasuredLength$fTextualMonoidMeasured$fIsStringMeasured$fStableFactorialMonoidMeasured$fFactorialMonoidMeasured$fRightGCDMonoidMeasured$fLeftGCDMonoidMeasured$fRightReductiveMonoidMeasured$fLeftReductiveMonoidMeasured$fPositiveMonoidMeasured$fMonoidNullMeasured$fMonoidMeasured $fOrdMeasuredoffset fullOffset lineStart extractLines extractOffset Positioned linesColumns linesColumns'const3fstOf4$fTextualMonoidLinePositioned$fTextualMonoidOffsetPositioned$fIsStringLinePositioned$fIsStringOffsetPositioned%$fStableFactorialMonoidLinePositioned'$fStableFactorialMonoidOffsetPositioned$fFactorialMonoidLinePositioned!$fFactorialMonoidOffsetPositioned$fRightGCDMonoidLinePositioned $fRightGCDMonoidOffsetPositioned$$fRightReductiveMonoidLinePositioned&$fRightReductiveMonoidOffsetPositioned$fLeftGCDMonoidLinePositioned$fLeftGCDMonoidOffsetPositioned#$fLeftReductiveMonoidLinePositioned%$fLeftReductiveMonoidOffsetPositioned$fPositiveMonoidLinePositioned $fPositiveMonoidOffsetPositioned$fMonoidNullLinePositioned$fMonoidNullOffsetPositioned$fMonoidLinePositioned$fMonoidOffsetPositioned$fShowLinePositioned$fShowOffsetPositioned$fOrdLinePositioned$fOrdOffsetPositioned$fEqLinePositioned$fEqOffsetPositioned$fPositionedLinePositioned$fPositionedOffsetPositioned$fApplicativeLinePositioned$fApplicativeOffsetPositioned$fFunctorLinePositioned$fFunctorOffsetPositioned$fTextualMonoidStateful$fIsStringStateful$fStableFactorialMonoidStateful$fFactorialMonoidStateful$fRightGCDMonoidStateful$fLeftGCDMonoidStateful$fRightReductiveMonoidStateful$fLeftReductiveMonoidStateful$fPositiveMonoidStateful$fMonoidNullStateful$fMonoidStateful$fApplicativeStateful$fFunctorStateful