8L      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKNone Subclass of L? for types whose values have no inverse, with the exception of M. More formally, the 1 class instances must satisfy the following law: #null (x <> y) == (null x && null y) Extension of L/ that allows testing a value for equality with M. 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. ,NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv+NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvNoneA subclass of . whose instances satisfy this additional law: , factors (a <> b) == factors a <> factors b 5Class of monoids that can be split into irreducible (i.e., atomic or prime)  in a unique way. Factors of  a w" are literally its prime factors: 9factors (Product 12) == [Product 2, Product 2, Product 3]Factors of a list are not0 its elements but all its single-item sublists:  factors "abc" == ["a", "b", "c"]6The methods of this class satisfy the following laws:   mconcat . factors == id  null == List.null . factors 8 List.all (\prime-> factors prime == [prime]) . factors ^ factors == unfoldr splitPrimePrefix == List.reverse . unfoldr (fmap swap . splitPrimeSuffix) - reverse == mconcat . List.reverse . factors 4 primePrefix == maybe mempty fst . splitPrimePrefix 4 primeSuffix == maybe mempty snd . splitPrimeSuffix ' foldl f a == List.foldl f a . factors ) foldl' f a == List.foldl' f a . factors ' foldr f a == List.foldr f a . factors K span p m == (mconcat l, mconcat r) where (l, r) = List.span p (factors m) 9 List.all (List.all (not . pred) . factors) . split pred 6 mconcat . intersperse prime . split (== prime) == id Q splitAt i m == (mconcat l, mconcat r) where (l, r) = List.splitAt i (factors m) -A minimal instance definition must implement  or (. Other methods are provided and should . be implemented only for performance reasons. 9Returns a list of all prime factors; inverse of mconcat. The prime prefix, M if none. The prime suffix, M if none. LSplits the argument into its prime prefix and the remaining suffix. Returns x for M. LSplits the argument into its prime suffix and the remaining prefix. Returns x for M. Like y from  Data.List on the list of primes. Like z 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.FoldableB, 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. kSplits the monoid into components delimited by prime separators satisfying the given predicate. The primes 8 satisfying the predicate are not a part of the result. Equivalent to ~ from  Data.List. Equivalent to  from  Data.List. 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. 1    None pClass 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 7 s == commonSuffix a b && a' <> s == a && b' <> s == b . where (a', b', s) = stripCommonSuffix a b oClass of monoids capable of finding the equivalent of greatest common divisor on the left side of two monoidal  values. The methods'b 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 7 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:  , isSuffixOf 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 3 than linear in the length of the suffix argument. %(Class of monoids with a left inverse of  , satisfying the following law:  , isPrefixOf 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 3 than linear in the length of the prefix argument. (nClass of Abelian monoids that allow the greatest common denominator to be found for any two given values. The - operations must satisfy the following laws:  1 gcd a b == commonPrefix a b == commonSuffix a b ( Just a' = a </> p && Just b' = b </> p  where p = gcd a b If a ( happens to also be a *5, it should additionally satisfy the following laws: ' gcd (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 <> operation. The class instances - must satisfy the following additional laws:  (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 ~ !"#$%&'()*+,-   !"#$%&'()*+,--+,*()%&'"#$! t !"#$%&'()*+,-  None.The . class is an extension of * specialized for monoids that can contain S characters. Its methods are generally equivalent to their namesake functions from  Data.List and  Data.Text, and " they satisfy the following laws:  1 unfoldr splitCharacterPrefix . fromString == id [ splitCharacterPrefix . primePrefix == fmap (\(c, t)-> (c, mempty)) . splitCharacterPrefix  / map f . fromString == fromString . List.map f J concatMap (fromString . f) . fromString == fromString . List.concatMap f  1 foldl ft fc a . fromString == List.foldl fc a 1 foldr ft fc a . fromString == List.foldr fc a 1 foldl' ft fc a . fromString == List.foldl' fc a  7 scanl f c . fromString == fromString . List.scanl f c 7 scanr f c . fromString == fromString . List.scanr f c D mapAccumL f a . fromString == fmap fromString . List.mapAccumL f a D 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 A .^ may contain non-character data insterspersed between its characters. Every class method that  returns a modified .L instance generally preserves this non-character data. All of the following  expressions are identities:   map 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 1. /(Contructs a new data type instance Like   , but from a   input instead of  . & fromText == fromString . Text.unpack 06Creates a prime monoid containing a single character.  singleton c == fromString [c] 1Specialized version of . Every prime factor of a Textual monoid must consist of a * single character or no character at all. 2oExtracts a single character that prefixes the monoid, if the monoid begins with a character. Otherwise returns  x. 4 characterPrefix == fmap fst . splitCharacterPrefix 3Equivalent to  from  Data.List with a  Char -> Char- function. Preserves all non-character data. $ map f == concatMap (singleton . f) 4Equivalent to  from  Data.List with a Char -> String' function. Preserves all non-character  data. 5Equivalent to  from  Data.List". Ignores all non-character data. 6Equivalent to  from  Data.List". Ignores all non-character data. 7pThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent  to y from  Data.List. 8Strict version of 7. 9pThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent  to { 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. @iThe first predicate tests the non-character data, the second one the characters. Otherwise equivalent to  ~ from  Data.List when applied to a  . AiThe first predicate tests the non-character data, the second one the characters. Otherwise equivalent to   from  Data.List when applied to a  . B' break pt pc'0 is equivalent to |span (not . pt) (not . pc)|. C' span pt pc t'< is equivalent to |(takeWhile pt pc t, dropWhile pt pc t)|. DhSplits the monoid into components delimited by character separators satisfying the given predicate. The C characters satisfying the predicate are not a part of the result. > split p == Factorial.split (maybe False p . characterPrefix) ELike  from  Data.List when applied to a  . Ignores non-character data. #./0123456789:;<=>?@ABCDE !"#./0123456789:;<=>?@ABCDE./0123456789:;<=>?@ABCDE ./0123456789:;<=>?@ABCDE !"#NoneH Takes a raw $ chunk and returns a pair of F* decoding the prefix of the chunk and the ^ remaining suffix that is either null or contains the incomplete last character of the chunk. FGH%&'()*+,-./0123456FGHFGHFGH%&'()*+,-./0123456NoneII a is a newtype wrapper around 7 a. The behaviour of the I a instances of monoid 3 subclasses is identical to the behaviour of their a instances, up to the K . 0 isomorphism. The only purpose of IO then is to change the performance characteristics of various operations. Most ( importantly, injecting a monoid into a I has the effect of making  a constant-time operation. 89I:JK;<=>?@ABCDEFGHIIJKIJKJ89I:JK;<=>?@ABCDEFGHIJ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEEFGHIJKLJKMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvJKwJxyJzJ{J|JzJzJzJzJzJzJzJzJ}J} ~JKJJ|J|:Jz;Jz<Jz=Jz>Jz?Jz@JzAJ{BJ{CJ{D      !"#$%&'()*+,,G-./0123456789:;<monoid-subclasses-0.3.3Data.Monoid.NullData.Monoid.FactorialData.Monoid.CancellativeData.Monoid.Textual%Data.Monoid.Instances.ByteString.UTF8Data.Monoid.Instances.ConcatPositiveMonoid MonoidNullnullStableFactorialMonoidFactorialMonoidfactors primePrefix primeSuffixsplitPrimePrefixsplitPrimeSuffixfoldlfoldl'foldrlengthfoldMapspanbreaksplit takeWhile dropWhilesplitAtdroptakereversemapMmapM_RightGCDMonoid commonSuffixstripCommonSuffix LeftGCDMonoid commonPrefixstripCommonPrefixRightCancellativeMonoidLeftCancellativeMonoidRightReductiveMonoid isSuffixOf stripSuffixLeftReductiveMonoid isPrefixOf stripPrefix GCDMonoidgcdCancellativeMonoidReductiveMonoidCommutativeMonoid TextualMonoidfromText singletonsplitCharacterPrefixcharacterPrefixmap concatMapanyallscanlscanl1scanrscanr1 mapAccumL mapAccumRfindByteStringUTF8decodeConcatextractinjectbase 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.Base Control.Monad$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-0.11.2.3Data.Text.InternalTextString foldlChars foldlOther foldrChars foldrOther$fTextualMonoidVector$fIsStringVector$fTextualMonoidSeq $fIsStringSeq$fTextualMonoidText$fTextualMonoidText0$fTextualMonoid[]bytestring-0.10.0.2Data.ByteString.Internal ByteStringwrapPair wrapTriplefromChartoChar groupASCII headIndexbyteStartsCharactercharStartIndex$fTextualMonoidByteStringUTF8$fFactorialMonoidByteStringUTF8$fPositiveMonoidByteStringUTF8$fIsStringByteStringUTF8$fShowByteStringUTF8$fLeftGCDMonoidByteStringUTF8&$fLeftCancellativeMonoidByteStringUTF8#$fLeftReductiveMonoidByteStringUTF8$fMonoidNullByteStringUTF8$fMonoidByteStringUTF8containers-0.5.0.0 Data.SequenceSeqPairinjectSingleton$fApplicativePair $fFunctorPair$fTextualMonoidConcat$fIsStringConcat$fFactorialMonoidConcat$fRightGCDMonoidConcat$fLeftGCDMonoidConcat$fRightReductiveMonoidConcat$fLeftReductiveMonoidConcat$fPositiveMonoidConcat$fMonoidNullConcat$fMonoidConcat $fOrdConcat $fEqConcat