E      !"#$%&'()*+,-./0123456789:;<=>?@ABCDNone Extension of E/ that allows testing a value for equality with F. The following law must hold: null x == (x == mempty)GHIJKLMNOPQRSTUVWXYZ[\GHIJKLMNOPQRSTUVWXYZ[\None5Class 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 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) It'*s worth noting that a class instance does not need to satisfy this law:  , factors (a <> b) == factors a <> factors b -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, F if none. The prime suffix, F if none. LSplits the argument into its prime prefix and the remaining suffix. Returns ^ for F. LSplits the argument into its prime suffix and the remaining prefix. Returns ^ for F. Like _ from  Data.List on the list of primes. Like ` from  Data.List on the list of primes. Like a from  Data.List on the list of primes. The   of the list of primes. Equivalent to b from  Data.ListG, except the argument function works on prime factors rather than list  elements. Like c from  Data.List on the list of primes. Equivalent to d 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 e from  Data.List. Equivalent to f from  Data.List. Like g from  Data.List on the list of primes. Equivalent to h from  Data.List. Equivalent to i from  Data.List. Equivalent to j from  Data.List. A k equivalent. A l equivalent. & mnopqrstuvwxyz{|   mnopqrstuvwxyz{|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 i !"#$%&'()*~ !"#$%&'()*)*(&'#$% !"_ !"#$%&'()*~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:  8 splitCharacterPrefix (singleton c <> t) == Just (c, t) [ 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 .. ,(Contructs a new data type instance Like  , but from a  input instead of . & fromText == fromString . Text.unpack -6Creates a prime monoid containing a single character.  singleton c == fromString [c] .Specialized version of . Every prime factor of a Textual monoid must consist of a * single character or no character at all. /oExtracts a single character that prefixes the monoid, if the monoid begins with a character. Otherwise returns  ^. 4 characterPrefix == fmap fst . splitCharacterPrefix 0Equivalent to b from  Data.List with a  Char -> Char- function. Preserves all non-character data. $ map f == concatMap (singleton . f) 1Equivalent to  from  Data.List with a Char -> String' function. Preserves all non-character  data. 2Equivalent to  from  Data.List". Ignores all non-character data. 3Equivalent to  from  Data.List". Ignores all non-character data. 4pThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent  to _ from  Data.List. 5Strict version of 4. 6pThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent  to a from  Data.List. 7Equivalent to  from  Data.List when applied to a (, but preserves all non-character data. 8Equivalent to  from  Data.List when applied to a (, but preserves all non-character data. * scanl f c == scanl1 f . (singleton c <>) 9Equivalent 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  e from  Data.List when applied to a . >iThe first predicate tests the non-character data, the second one the characters. Otherwise equivalent to  f from  Data.List when applied to a . ?' break pt pc'0 is equivalent to |span (not . pt) (not . pc)|. @' span pt pc t'< is equivalent to |(takeWhile pt pc t, dropWhile pt pc t)|. AhSplits 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) BLike  from  Data.List when applied to a . Ignores non-character data. +,-./0123456789:;<=>?@AB+,-./0123456789:;<=>?@AB+,-./0123456789:;<=>?@AB+,-./0123456789:;<=>?@ABNoneCDCDCDCD      !"#$%&'()*+,-./0123456789:;<=>?@@ABCABDEFGHIJKLMNOPQRSTUVWXYZAB[A\]A^A_A`A`A^A^A^A^A^A^A^A^AaAabcdefghijklmnopqABrstuvwxyz{|}~AA`A^6A^7A^8A^9A^:A^;A^<A_=A_>A_?monoid-subclasses-0.1Data.Monoid.NullData.Monoid.FactorialData.Monoid.CancellativeData.Monoid.Textual%Data.Monoid.Instances.ByteString.UTF8 MonoidNullnullFactorialMonoidfactors primePrefix primeSuffixsplitPrimePrefixsplitPrimeSuffixfoldlfoldl'foldrlengthmapspanbreaksplit takeWhile dropWhilesplitAtdroptakereversemapMmapM_RightGCDMonoid commonSuffixstripCommonSuffix LeftGCDMonoid commonPrefixstripCommonPrefixRightCancellativeMonoidLeftCancellativeMonoidRightReductiveMonoid isSuffixOf stripSuffixLeftReductiveMonoid isPrefixOf stripPrefix GCDMonoidgcdCancellativeMonoidReductiveMonoid TextualMonoidfromText singletonsplitCharacterPrefixcharacterPrefix concatMapanyallscanlscanl1scanrscanr1 mapAccumL mapAccumRfindByteStringUTF8base Data.MonoidMonoidmempty$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$fFactorialMonoidVector$fFactorialMonoidSet$fFactorialMonoidSeq$fFactorialMonoidIntSet$fFactorialMonoidIntMap$fFactorialMonoidMap$fFactorialMonoidText$fFactorialMonoidText0$fFactorialMonoidByteString$fFactorialMonoidByteString0$fFactorialMonoid[]$fFactorialMonoid(,)$fFactorialMonoidMaybe$fFactorialMonoidProduct$fFactorialMonoidSum$fFactorialMonoidDualmappend$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$fGCDMonoidSet$fRightGCDMonoidSet$fLeftGCDMonoidSet$fReductiveMonoidSet$fRightReductiveMonoidSet$fLeftReductiveMonoidSet$fRightGCDMonoid(,)$fLeftGCDMonoid(,)$fRightCancellativeMonoid(,)$fLeftCancellativeMonoid(,)$fRightReductiveMonoid(,)$fLeftReductiveMonoid(,)$fGCDMonoid(,)$fCancellativeMonoid(,)$fReductiveMonoid(,)$fRightGCDMonoidProduct$fLeftGCDMonoidProduct$fRightReductiveMonoidProduct$fLeftReductiveMonoidProduct$fGCDMonoidProduct$fReductiveMonoidProduct$fRightGCDMonoidSum$fLeftGCDMonoidSum$fRightCancellativeMonoidSum$fLeftCancellativeMonoidSum$fRightReductiveMonoidSum$fLeftReductiveMonoidSum$fGCDMonoidSum$fCancellativeMonoidSum$fReductiveMonoidSum$fLeftGCDMonoidDual$fRightGCDMonoidDual$fLeftCancellativeMonoidDual$fRightCancellativeMonoidDual$fLeftReductiveMonoidDual$fRightReductiveMonoidDual$fGCDMonoidDual$fCancellativeMonoidDual$fReductiveMonoidDual Data.String fromString text-0.11.2.3Data.Text.InternalTextString foldlChars foldlOther foldrChars foldrOther$fTextualMonoidText$fTextualMonoidText0$fTextualMonoid[]wrapPair$fTextualMonoidByteStringUTF8$fFactorialMonoidByteStringUTF8$fIsStringByteStringUTF8