!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                 TrustworthyAY 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 bClass 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 % 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 " must satisfy the following laws: ;maybe a (b <>) (a </> b) == a maybe a (<> b) (a </> b) == a[Class of all Abelian ({i.e.}, commutative) monoids that satisfy the commutativity property: a <> b == b <> a     5 TrustworthyI; Subclass of ? for types whose values have no inverse, with the exception of E. More formally, the class instances must satisfy the following law:#null (x <> y) == (null x && null y) Extension of / that allows testing a value for equality with . 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. Trustworthy|9A 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.inits . 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,  if none.The prime suffix,  if none.LSplits the argument into its prime prefix and the remaining suffix. Returns  for .LSplits the argument into its prime suffix and the remaining prefix. Returns  for .2Returns the list of all prefixes of the argument,  first.2Returns the list of all suffixes of the argument,  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. Trustworthy;=}"The  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 r may contain non-character data insterspersed between its characters. Every class method that returns a modified D 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 ') that ignores the non-character data.0All of the following expressions are identities: Smap 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) toString undefined . fromString(Contructs a new data type instance Like  , but from a  input instead of . $fromText == fromString . Text.unpack5Creates a prime monoid containing a single character. singleton c == fromString [c]Specialized version of . Every prime factor of a TextualC monoid must consist of a single character or no character at all.pExtracts a single character that prefixes the monoid, if the monoid begins with a character. Otherwise returns . 2characterPrefix == fmap fst . splitCharacterPrefixEquivalent to  from  Data.List with a  Char -> Char, function. Preserves all non-character data. "map f == concatMap (singleton . f)Equivalent to  from  Data.List with a Char -> String- function. Preserves all non-character data.Returns the list of characters the monoid contains, after having the argument function convert all its non-character factors into characters.Equivalent to  from  Data.List!. Ignores all non-character data.Equivalent to  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 .tThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent to 'List.foldl\'' from  Data.List.Equivalent to  from  Data.List when applied to a ', but preserves all non-character data.Equivalent to  from  Data.List when applied to a ', but preserves all non-character data. (scanl f c == scanl1 f . (singleton c <>)Equivalent to  from  Data.List when applied to a ', but preserves all non-character data.Equivalent to  from  Data.List when applied to a ', but preserves all non-character data. (scanr f c == scanr1 f . (<> singleton c)Equivalent to  from  Data.List when applied to a (, but preserves all non-character data. Equivalent to  from  Data.List when applied to a (, but preserves all non-character data. jThe first predicate tests the non-character data, the second one the characters. Otherwise equivalent to  from  Data.List when applied to a . jThe first predicate tests the non-character data, the second one the characters. Otherwise equivalent to  from  Data.List when applied to a . <'break pt pc' is equivalent to |span (not . pt) (not . pc)|. I'span pt pc t' is equivalent to |(takeWhile pt pc t, dropWhile pt pc t)|.A stateful variant of  B, threading the result of the test function as long as it returns .Strict version of .Splits 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)Like  from  Data.List when applied to a . Ignores non-character data.Like  from  Data.List when applied to a . Ignores non-character data. foldl_ = foldl const takeWhile_ = takeWhile . const dropWhile_ = dropWhile . const break_ = break . const span_ = span . const )spanMaybe_ s = spanMaybe s (const . Just)%     %     $     Safe_"" a b is a wrapper around the  b that carries the state a along. The state type a must be a monoid as well if " is to be of any use. In the  and  class instances, the monoid b has the priority and the state a is left for the end."#$%&"#$%&"#SafeӰ9the current linethe current offset=the current column89:<;=:89;<9=89:;<Safebb 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.d Create a new b value.bcdbcdcbcSafe%tt; is a transparent monoid transformer. The behaviour of the t aH instances of monoid subclasses is identical to the behaviour of their a instances, up to the  isomorphism.The only purpose of tu then is to change the performance characteristics of various operations. Most importantly, injecting a monoid into t has the effect of making ! a constant-time operation. The  and  operations are amortized to constant time, provided that only one or the other is used. Using both operations alternately will trigger the worst-case behaviour of O(n).tuvwtuvwt Noned Takes a raw  chunk and returns a pair of  decoding the prefix of the chunk and the remaining suffix that is either null or contains the incomplete last character of the chunk.     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !""#$%&'()*+,-./0123456789#:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`#abcdefghijklmnopqr#stuvwxyz{|}~                     79`.monoid-subclasses-0.4.6-81AYqLBOZ84ABbS0WSoF2UData.Monoid.CancellativeData.Monoid.NullData.Monoid.FactorialData.Monoid.TextualData.Monoid.Instances.Stateful Data.Monoid.Instances.PositionedData.Monoid.Instances.MeasuredData.Monoid.Instances.Concat%Data.Monoid.Instances.ByteString.UTF8RightGCDMonoid commonSuffixstripCommonSuffix LeftGCDMonoid commonPrefixstripCommonPrefixRightCancellativeMonoidLeftCancellativeMonoidRightReductiveMonoid isSuffixOf stripSuffixLeftReductiveMonoid isPrefixOf stripPrefix GCDMonoidgcdCancellativeMonoidReductiveMonoidCommutativeMonoid$fCommutativeMonoidIntSet$fCommutativeMonoidSet$fCommutativeMonoid(,,,)$fCommutativeMonoid(,,)$fCommutativeMonoid(,)$fCommutativeMonoidProduct$fCommutativeMonoidSum$fCommutativeMonoidDual$fCommutativeMonoid()$fLeftReductiveMonoidText$fLeftReductiveMonoidText0$fLeftReductiveMonoidByteString $fLeftReductiveMonoidByteString0$fLeftReductiveMonoidVector$fLeftReductiveMonoidSeq$fLeftReductiveMonoid[]$fLeftReductiveMonoidIntMap$fLeftReductiveMonoidMap$fLeftReductiveMonoidMaybe$fLeftReductiveMonoid(,,,)$fLeftReductiveMonoid(,,)$fLeftReductiveMonoid(,)$fLeftReductiveMonoid()$fRightReductiveMonoidText$fRightReductiveMonoidText0 $fRightReductiveMonoidByteString!$fRightReductiveMonoidByteString0$fRightReductiveMonoidVector$fRightReductiveMonoidSeq$fRightReductiveMonoidMaybe$fRightReductiveMonoid(,,,)$fRightReductiveMonoid(,,)$fRightReductiveMonoid(,)$fLeftReductiveMonoidDual$fRightReductiveMonoidDual$fRightReductiveMonoid()$fReductiveMonoidIntSet$fRightReductiveMonoidIntSet$fLeftReductiveMonoidIntSet$fReductiveMonoidSet$fRightReductiveMonoidSet$fLeftReductiveMonoidSet$fReductiveMonoid(,,,)$fReductiveMonoid(,,)$fReductiveMonoid(,)$fRightReductiveMonoidProduct$fLeftReductiveMonoidProduct$fReductiveMonoidProduct$fRightReductiveMonoidSum$fLeftReductiveMonoidSum$fReductiveMonoidSum$fReductiveMonoidDual$fReductiveMonoid()$fLeftCancellativeMonoidText$fLeftCancellativeMonoidText0"$fLeftCancellativeMonoidByteString#$fLeftCancellativeMonoidByteString0$fLeftCancellativeMonoidVector$fLeftCancellativeMonoidSeq$fLeftCancellativeMonoid[]$fLeftCancellativeMonoid(,,,)$fLeftCancellativeMonoid(,,)$fLeftCancellativeMonoid(,)$fLeftCancellativeMonoidSum$fLeftCancellativeMonoid()$fRightCancellativeMonoidText$fRightCancellativeMonoidText0#$fRightCancellativeMonoidByteString$$fRightCancellativeMonoidByteString0$fRightCancellativeMonoidVector$fRightCancellativeMonoidSeq$fRightCancellativeMonoid(,,,)$fRightCancellativeMonoid(,,)$fRightCancellativeMonoid(,)$fRightCancellativeMonoidSum$fLeftCancellativeMonoidDual$fRightCancellativeMonoidDual$fRightCancellativeMonoid()$fCancellativeMonoid(,,,)$fCancellativeMonoid(,,)$fCancellativeMonoid(,)$fCancellativeMonoidSum$fCancellativeMonoidDual$fCancellativeMonoid()$fLeftGCDMonoidText$fLeftGCDMonoidText0$fLeftGCDMonoidByteString$fLeftGCDMonoidByteString0$fLeftGCDMonoidVector$fLeftGCDMonoidSeq$fLeftGCDMonoid[]$fLeftGCDMonoidIntMap$fLeftGCDMonoidMap$fLeftGCDMonoidIntSet$fLeftGCDMonoidSet$fLeftGCDMonoidMaybe$fLeftGCDMonoid(,,,)$fLeftGCDMonoid(,,)$fLeftGCDMonoid(,)$fLeftGCDMonoid()$fRightGCDMonoidByteString$fRightGCDMonoidByteString0$fRightGCDMonoidVector$fRightGCDMonoidSeq$fRightGCDMonoidIntSet$fRightGCDMonoidSet$fRightGCDMonoidMaybe$fRightGCDMonoid(,,,)$fRightGCDMonoid(,,)$fRightGCDMonoid(,)$fLeftGCDMonoidDual$fRightGCDMonoidDual$fRightGCDMonoid()$fGCDMonoidIntSet$fGCDMonoidSet$fGCDMonoid(,,,)$fGCDMonoid(,,)$fGCDMonoid(,)$fRightGCDMonoidProduct$fLeftGCDMonoidProduct$fGCDMonoidProduct$fRightGCDMonoidSum$fLeftGCDMonoidSum$fGCDMonoidSum$fGCDMonoidDual $fGCDMonoid()PositiveMonoid MonoidNullnull$fMonoidNullVector$fMonoidNullSet$fMonoidNullSeq$fMonoidNullIntSet$fMonoidNullIntMap$fMonoidNullMap$fMonoidNullText$fMonoidNullText0$fMonoidNullByteString$fMonoidNullByteString0$fMonoidNull[]$fMonoidNull(,,,)$fMonoidNull(,,)$fMonoidNull(,)$fMonoidNullMaybe$fMonoidNullProduct$fMonoidNullSum$fMonoidNullDual$fMonoidNullLast$fMonoidNullFirst$fMonoidNullAny$fMonoidNullAll$fMonoidNullOrdering$fMonoidNull()$fPositiveMonoidVector$fPositiveMonoidSet$fPositiveMonoidSeq$fPositiveMonoidIntSet$fPositiveMonoidIntMap$fPositiveMonoidMap$fPositiveMonoid[]$fPositiveMonoidDual$fPositiveMonoidLast$fPositiveMonoidFirst$fPositiveMonoidMaybe$fPositiveMonoidText$fPositiveMonoidText0$fPositiveMonoidByteString$fPositiveMonoidByteString0$fPositiveMonoidAny$fPositiveMonoidAll$fPositiveMonoidOrdering$fPositiveMonoid()StableFactorialMonoidFactorialMonoidfactors primePrefix primeSuffixsplitPrimePrefixsplitPrimeSuffixinitstailsfoldlfoldl'foldrlengthfoldMapspanbreaksplit takeWhile dropWhile spanMaybe spanMaybe'splitAtdroptakereversemapMmapM_$fFactorialMonoidVector$fFactorialMonoidSet$fFactorialMonoidSeq$fFactorialMonoidIntSet$fFactorialMonoidIntMap$fFactorialMonoidMap$fFactorialMonoidText$fFactorialMonoidText0$fFactorialMonoidByteString$fFactorialMonoidByteString0$fFactorialMonoid[]$fFactorialMonoid(,,,)$fFactorialMonoid(,,)$fFactorialMonoid(,)$fFactorialMonoidMaybe$fFactorialMonoidProduct$fFactorialMonoidSum$fFactorialMonoidDual$fFactorialMonoid()$fStableFactorialMonoidVector$fStableFactorialMonoidSeq$fStableFactorialMonoidText$fStableFactorialMonoidText0!$fStableFactorialMonoidByteString"$fStableFactorialMonoidByteString0$fStableFactorialMonoid[]$fStableFactorialMonoidDual$fStableFactorialMonoid() TextualMonoidfromText singletonsplitCharacterPrefixcharacterPrefixmap concatMaptoStringanyallscanlscanl1scanrscanr1 mapAccumL mapAccumRfindelemfoldl_foldl_'foldr_ takeWhile_ dropWhile_break_span_ spanMaybe_ spanMaybe_'$fIsStringVector$fTextualMonoidVector$fTextualMonoidSeq$fTextualMonoidText$fTextualMonoidText0$fTextualMonoid[]StatefulextractstatesetState$fTextualMonoidStateful$fIsStringStateful$fStableFactorialMonoidStateful$fFactorialMonoidStateful$fRightGCDMonoidStateful$fLeftGCDMonoidStateful$fRightReductiveMonoidStateful$fLeftReductiveMonoidStateful$fPositiveMonoidStateful$fMonoidNullStateful$fMonoidStateful$fSemigroupStateful$fApplicativeStateful$fFunctorStateful $fEqStateful $fOrdStateful$fShowStatefulLinePositionedlineOffsetPositionedpositioncolumn$fTextualMonoidOffsetPositioned$fIsStringOffsetPositioned'$fStableFactorialMonoidOffsetPositioned!$fFactorialMonoidOffsetPositioned $fRightGCDMonoidOffsetPositioned&$fRightReductiveMonoidOffsetPositioned$fLeftGCDMonoidOffsetPositioned%$fLeftReductiveMonoidOffsetPositioned $fPositiveMonoidOffsetPositioned$fMonoidNullOffsetPositioned$fMonoidOffsetPositioned$fSemigroupOffsetPositioned$fShowOffsetPositioned$fOrdOffsetPositioned$fEqOffsetPositioned$fPositionedOffsetPositioned$fApplicativeOffsetPositioned$fFunctorOffsetPositioned$fTextualMonoidLinePositioned$fIsStringLinePositioned%$fStableFactorialMonoidLinePositioned$fFactorialMonoidLinePositioned$fRightGCDMonoidLinePositioned$$fRightReductiveMonoidLinePositioned$fLeftGCDMonoidLinePositioned#$fLeftReductiveMonoidLinePositioned$fPositiveMonoidLinePositioned$fMonoidNullLinePositioned$fMonoidLinePositioned$fSemigroupLinePositioned$fShowLinePositioned$fOrdLinePositioned$fEqLinePositioned$fPositionedLinePositioned$fApplicativeLinePositioned$fFunctorLinePositionedMeasuredmeasure$fTextualMonoidMeasured$fIsStringMeasured$fStableFactorialMonoidMeasured$fFactorialMonoidMeasured$fRightGCDMonoidMeasured$fLeftGCDMonoidMeasured$fRightReductiveMonoidMeasured$fLeftReductiveMonoidMeasured$fPositiveMonoidMeasured$fMonoidNullMeasured$fMonoidMeasured$fSemigroupMeasured $fOrdMeasured $fEqMeasured$fShowMeasuredConcat concatenateforce$fTextualMonoidConcat$fIsStringConcat$fStableFactorialMonoidConcat$fFactorialMonoidConcat$fRightGCDMonoidConcat$fLeftGCDMonoidConcat$fRightReductiveMonoidConcat$fLeftReductiveMonoidConcat$fPositiveMonoidConcat$fMonoidNullConcat$fMonoidConcat$fSemigroupConcat$fFoldableConcat$fApplicativeConcat$fFunctorConcat $fOrdConcat $fEqConcat $fShowConcatByteStringUTF8decode$fTextualMonoidByteStringUTF8$fFactorialMonoidByteStringUTF8$fPositiveMonoidByteStringUTF8$fIsStringByteStringUTF8$fShowByteStringUTF8$fLeftGCDMonoidByteStringUTF8&$fLeftCancellativeMonoidByteStringUTF8#$fLeftReductiveMonoidByteStringUTF8$fMonoidNullByteStringUTF8$fMonoidByteStringUTF8$fSemigroupByteStringUTF8$fEqByteStringUTF8$fOrdByteStringUTF8base Data.Monoid<>GHC.BasemappendMonoidmemptyProductNothing Data.FoldableGHC.ListJustData.Traversable Data.String fromString#text-1.2.2.2-EakMpasry3jA6OIwSZhq9MData.Text.InternalTextStringoffset fullOffset lineStart extractLines extractOffset Positioned_measuredLengthpureLeaf:<>bytestring-0.10.8.2Data.ByteString.Internal ByteString