!kNO      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr s t u v w x y z { | } ~                                                                                                    Trustworthy=? monoid-subclasses 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)monoid-subclasses 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=?H(0monoid-subclassesHelper class to avoid FlexibleInstances2monoid-subclasses Subclass of 7 where 9 is a complete inverse of +, satisfying the following additional law:  stripSuffix b (a <> b) == Just a3monoid-subclasses Subclass of 7 where 9 is a complete inverse of +, satisfying the following additional law:  stripPrefix a (a <> b) == Just b4monoid-subclasses,Class of semigroups 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)8Every instance definition has to implement at least the 6 method.7monoid-subclasses+Class of semigroups 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)8Every instance definition has to implement at least the 9 method.:monoid-subclasses Subclass of ; where <( is a complete inverse of the Semigroup L operation. The class instances must satisfy the following additional laws: 1(a <> b) </> a == Just b (a <> b) </> b == Just a;monoid-subclassesEClass of Abelian semigroups with a partial inverse for the Semigroup " operation. The inverse operation <" must satisfy the following laws: ;maybe a (b <>) (a </> b) == a maybe a (<> b) (a </> b) == aThe < operator is a synonym for both 9 and 6, which must be equivalent as & is both associative and commutative. 1(</>) = flip stripPrefix (</>) = flip stripSuffix=monoid-subclassesClass of all Abelian (i.e.B, commutative) semigroups that satisfy the commutativity property: a <> b == b <> a@monoid-subclassesHmonoid-subclassesO(n)Imonoid-subclassesO(n)Jmonoid-subclassesO(n)Kmonoid-subclassesO(n)Lmonoid-subclassesO(n)Mmonoid-subclasses!O(log(min(m,n"m)) + prefixLength)Nmonoid-subclassesO(prefixLength)Omonoid-subclassesO(m+n)Pmonoid-subclassesO(m+n)Umonoid-subclassesO(1)Vmonoid-subclassesO(n)Wmonoid-subclassesO(n)Xmonoid-subclassesO(n)Ymonoid-subclassesO(n)Zmonoid-subclassesO(n)[monoid-subclasses!O(log(min(m,n"m)) + suffixLength)\monoid-subclassesO(m+n)]monoid-subclassesO(m+n)^monoid-subclassesO(m+n)emonoid-subclassesO(1)fmonoid-subclassesO(m+n)gmonoid-subclassesO(m+n)hmonoid-subclassesO(m+n)imonoid-subclasses O(m*log(nm + 1)), m <= n/jmonoid-subclasses O(m*log(nm + 1)), m <= n/kmonoid-subclasses O(m*log(nm + 1)), m <= n/lmonoid-subclassesmonoid-subclassesmonoid-subclassesO(1)monoid-subclassesO(1)monoid-subclassesO(1)0123456798:;<==;<:0179845632<5 Trustworthy=?c`monoid-subclasses^Class of monoids for which the greatest overlap can be found between any two values, such that -a == a' <> overlap a b b == overlap a b <> b',The methods must satisfy the following laws: stripOverlap a b == (stripSuffixOverlap b a, overlap a b, stripPrefixOverlap a b) stripSuffixOverlap b a <> overlap a b == a overlap a b <> stripPrefixOverlap a b == bThe result of  overlap a b must be the largest prefix of b and suffix of a8, in the sense that it is contained in any other value x that satifies the property (x 8 b) && (x 5 a): <(x `isPrefixOf` overlap a b) && (x `isSuffixOf` overlap a b)?and it must be unique so it's not contained in any other value y" that satisfies the same property (y 8 b) && (y 5 a): Vnot ((y `isPrefixOf` overlap a b) && (y `isSuffixOf` overlap a b) && y /= overlap a b)monoid-subclasses9Class of Abelian monoids with monus. The monus operation  is a synonym for both  and , which must be equivalent as % is both associative and commutative: ?(<\>) = flip stripPrefixOverlap (<\>) = flip stripSuffixOverlapmonoid-subclassesO(m*n)monoid-subclasses O(min(m,n)^2)monoid-subclassesO(m*n)monoid-subclasses O(min(m,n)^2)monoid-subclasses O(min(m,n)^2)monoid-subclasses O(min(m,n)^2)monoid-subclassesO(m*n)monoid-subclassesO(m+n)monoid-subclassesO(m+n)monoid-subclassesO(1)monoid-subclassesO(m+n)monoid-subclassesO(m+n)monoid-subclasses O(m*log(nm + 1)), m <= n/monoid-subclasses O(m*log(nm + 1)), m <= n/monoid-subclassesO(1)monoid-subclassesO(1)monoid-subclassesO(1)monoid-subclassesO(1)monoid-subclassesO(1)5 Trustworthy=?+"monoid-subclassesClass of monoids capable of finding the equivalent of greatest common divisor on the right side of two monoidal values. 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 Furthermore, _ must return the unique greatest common suffix that contains, as its suffix, any other suffix x of both values: Mnot (x `isSuffixOf` a && x `isSuffixOf` b) || x `isSuffixOf` commonSuffix a b<and it cannot itself be a prefix of any other common suffix y of both values: Mnot (y `isSuffixOf` a && y `isSuffixOf` b && commonSuffix a b `isPrefixOf` y)monoid-subclassesClass of monoids capable of finding the equivalent of greatest common divisor on the left side of two monoidal values. 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 Furthermore, _ must return the unique greatest common prefix that contains, as its prefix, any other prefix x of both values: Mnot (x `isPrefixOf` a && x `isPrefixOf` b) || x `isPrefixOf` commonPrefix a b<and it cannot itself be a suffix of any other common prefix y of both values: Mnot (y `isPrefixOf` a && y `isPrefixOf` b && commonPrefix a b `isSuffixOf` y)monoid-subclassesClass of Abelian monoids that allow the greatest common divisor 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 :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 <> cmonoid-subclassesO(prefixLength)monoid-subclassesO(prefixLength)monoid-subclassesO(prefixLength)monoid-subclassesO(prefixLength)monoid-subclassesO(prefixLength)monoid-subclassesO(prefixLength)monoid-subclassesO(prefixLength)monoid-subclassesO(m+n)monoid-subclassesO(m+n)monoid-subclassesO(m+n)monoid-subclassesO(m*log(n/m + 1)), m <= nmonoid-subclassesO(1)monoid-subclassesO(m+n)monoid-subclassesO(suffixLength)monoid-subclassesO(suffixLength)monoid-subclassesO(suffixLength)monoid-subclassesO(suffixLength)monoid-subclassesO(suffixLength)monoid-subclassesO(m+n)monoid-subclassesO(m+n)monoid-subclassesO(m*log(n/m + 1)), m <= nmonoid-subclassesO(1)monoid-subclassesO(m+n)monoid-subclassesO(m*log(n/m + 1)), m <= nmonoid-subclassesO(1)monoid-subclassesO(1)monoid-subclassesO(1)monoid-subclassesO(1)monoid-subclassesO(1)monoid-subclassesO(1)monoid-subclassesO(1) Safe,=?"0123456798:;<= Trustworthy=? monoid-subclassesA subclass of - whose instances satisfy this additional law: *factors (a <> b) == factors a <> factors bmonoid-subclasses8Class of semigroups 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: Mmaybe id sconcat . nonEmpty . factors == id List.all (\prime-> factors prime == [prime]) . factors factors . reverse == List.reverse . factors primePrefix s == foldr const s s primeSuffix s == primePrefix (reverse s) foldl f a == List.foldl f a . factors foldl' f a == List.foldl' f a . factors foldr f a == List.foldr f a . factors-A minimal instance definition must implement  or L. Other methods can and should be implemented only for performance reasons.monoid-subclasses8Returns a list of all prime factors; inverse of mconcat.monoid-subclassesThe prime prefix; primePrefix mempty == mempty for monoids.monoid-subclassesThe prime suffix; primeSuffix mempty == mempty for monoids.monoid-subclassesLike  from  Data.List on the list of primes.monoid-subclassesLike  from  Data.List on the list of primes.monoid-subclassesLike  from  Data.List on the list of primes.monoid-subclassesThe  of the list of primes.monoid-subclasses Generalizes  from  Data.FoldableV, except the function arguments are prime factors rather than the structure elements.monoid-subclassesEquivalent to  from  Data.List.monoid-subclassesA  equivalent.monoid-subclassesA  equivalent.   Trustworthy,=?'monoid-subclasses5Class 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"]MThe methods of this class satisfy the following laws in addition to those of : &null == List.null . 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 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 should implement (> for performance reasons, and other methods where beneficial.(monoid-subclassesLSplits the argument into its prime prefix and the remaining suffix. Returns  for .)monoid-subclassesLSplits the argument into its prime suffix and the remaining prefix. Returns  for .*monoid-subclasses2Returns the list of all prefixes of the argument,  first.+monoid-subclasses2Returns the list of all suffixes of the argument,  last.,monoid-subclassesLike  from  Data.List on the list of primes.-monoid-subclassesEquivalent to  from  Data.List..monoid-subclassesSplits the monoid into components delimited by prime separators satisfying the given predicate. The primes satisfying the predicate are not a part of the result./monoid-subclassesEquivalent to  from  Data.List.0monoid-subclassesEquivalent to  from  Data.List.1monoid-subclassesA stateful variant of ,B, threading the result of the test function as long as it returns .2monoid-subclassesStrict version of 1.3monoid-subclassesLike  from  Data.List on the list of primes.4monoid-subclassesEquivalent to  from  Data.List.5monoid-subclassesEquivalent to  from  Data.List.&'/0543,-*+.()12'/0543,-*+.()12&Safe=?2"Imonoid-subclassesThe I 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 Ir may contain non-character data insterspersed between its characters. Every class method that returns a modified ID instance generally preserves this non-character data. Methods like U 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 g') 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 . fromStringJmonoid-subclasses(Contructs a new data type instance Like  , but from a  input instead of . $fromText == fromString . Text.unpackKmonoid-subclasses5Creates a prime monoid containing a single character. singleton c == fromString [c]Lmonoid-subclassesSpecialized version of (. Every prime factor of a TextualC monoid must consist of a single character or no character at all.Mmonoid-subclassespExtracts a single character that prefixes the monoid, if the monoid begins with a character. Otherwise returns . 2characterPrefix == fmap fst . splitCharacterPrefixNmonoid-subclassesEquivalent to  from  Data.List with a  Char -> Char, function. Preserves all non-character data. "map f == concatMap (singleton . f)Omonoid-subclassesEquivalent to   from  Data.List with a Char -> String- function. Preserves all non-character data.Pmonoid-subclassesReturns the list of characters the monoid contains, once the argument function converts all its non-character factors into characters.Qmonoid-subclassesEquivalent to   from  Data.List!. Ignores all non-character data.Rmonoid-subclassesEquivalent to   from  Data.List!. Ignores all non-character data.Smonoid-subclassestThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent to  from  Data.List.Tmonoid-subclassesStrict version of S.Umonoid-subclassestThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent to 'List.foldl\'' from  Data.List.Vmonoid-subclassesEquivalent to   from  Data.List when applied to a ', but preserves all non-character data.Wmonoid-subclassesEquivalent to   from  Data.List when applied to a ', but preserves all non-character data. (scanl f c == scanl1 f . (singleton c <>)Xmonoid-subclassesEquivalent to  from  Data.List when applied to a ', but preserves all non-character data.Ymonoid-subclassesEquivalent to  from  Data.List when applied to a ', but preserves all non-character data. (scanr f c == scanr1 f . (<> singleton c)Zmonoid-subclassesEquivalent to  from  Data.List when applied to a (, but preserves all non-character data.[monoid-subclassesEquivalent to  from  Data.List when applied to a (, but preserves all non-character data.\monoid-subclassesjThe first predicate tests the non-character data, the second one the characters. Otherwise equivalent to  from  Data.List when applied to a .]monoid-subclassesjThe first predicate tests the non-character data, the second one the characters. Otherwise equivalent to  from  Data.List when applied to a .^monoid-subclasses'break pt pc' is equivalent to span (not . pt) (not . pc)._monoid-subclasses 'span pt pc t' is equivalent to &(takeWhile pt pc t, dropWhile pt pc t).`monoid-subclassesA stateful variant of _B, threading the result of the test function as long as it returns .amonoid-subclassesStrict version of `.bmonoid-subclassesSplits 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)cmonoid-subclassesLike  from  Data.List when applied to a . Ignores non-character data.dmonoid-subclassesLike  from  Data.List when applied to a . Ignores non-character data.emonoid-subclasses foldl_ = foldl consthmonoid-subclasses takeWhile_ = takeWhile . constimonoid-subclasses dropWhile_ = dropWhile . constjmonoid-subclasses break_ = break . constkmonoid-subclasses span_ = span . constlmonoid-subclasses )spanMaybe_ s = spanMaybe s (const . Just)%INUSTVWXY\]_^QRdOcZ[KbkJ`aLMPefghijlm%INUSTVWXY\]_^QRdOcZ[KbkJ`aLMPefghijlm  Trustworthy=?4G Safe8tmonoid-subclassest 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 t is to be of any use. In the ' and I class instances, the monoid b has the priority and the state a is left for the end.tuvwxtuvwx Safe:monoid-subclassesthe current linemonoid-subclassesthe current offsetmonoid-subclassesthe current column Safe?Zmonoid-subclasses 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.monoid-subclasses Create a new  value. SafeHmonoid-subclasses; is a transparent monoid transformer. The behaviour of the  aH instances of monoid subclasses is identical to the behaviour of their a instances, up to the  isomorphism.The only purpose of u then is to change the performance characteristics of various operations. Most importantly, injecting a monoid into  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).NoneN3monoid-subclasses 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.monoid-subclassesO(prefixLength)monoid-subclassesO(n)monoid-subclassesO(1)monoid-subclassesO(n)monoid-subclassesO(n) !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg>?<;@A=hijklmnopqrstuv w x y y z { | } ~                    z                                          z                    z                    ;<>?BCD]^`abcdefghi    monoid-subclasses-1.0-inplaceData.Monoid.NullData.Semigroup.CancellativeData.Monoid.MonusData.Monoid.GCDData.Monoid.CancellativeData.Semigroup.FactorialData.Monoid.FactorialData.Monoid.Textual Data.Monoid.Instances.CharVectorData.Monoid.Instances.Stateful Data.Monoid.Instances.PositionedData.Monoid.Instances.MeasuredData.Monoid.Instances.Concat%Data.Monoid.Instances.ByteString.UTF8PositiveMonoid 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$fPositiveMonoidSum$fPositiveMonoidProduct$fPositiveMonoidText$fPositiveMonoidText0$fPositiveMonoidByteString$fPositiveMonoidByteString0$fPositiveMonoidAny$fPositiveMonoidAll$fPositiveMonoidOrdering$fPositiveMonoid()SumCancellativecancelAdditionRightCancellativeLeftCancellativeRightReductive isSuffixOf stripSuffix LeftReductive isPrefixOf stripPrefix Cancellative Reductive Commutative$fCommutativeIntSet$fCommutativeSet$fCommutativeMaybe$fCommutative(,,,)$fCommutative(,,)$fCommutative(,)$fCommutativeProduct$fCommutativeSum$fCommutativeDual$fCommutative()$fLeftReductiveText$fLeftReductiveText0$fLeftReductiveByteString$fLeftReductiveByteString0$fLeftReductiveVector$fLeftReductiveSeq$fLeftReductive[]$fLeftReductiveIntMap$fLeftReductiveMap$fLeftReductiveMaybe$fLeftReductive(,,,)$fLeftReductive(,,)$fLeftReductive(,)$fLeftReductive()$fRightReductiveText$fRightReductiveText0$fRightReductiveByteString$fRightReductiveByteString0$fRightReductiveVector$fRightReductiveSeq$fRightReductive[]$fRightReductiveIntMap$fRightReductiveMap$fRightReductiveMaybe$fRightReductive(,,,)$fRightReductive(,,)$fRightReductive(,)$fLeftReductiveDual$fRightReductiveDual$fRightReductive()$fReductiveIntSet$fRightReductiveIntSet$fLeftReductiveIntSet$fReductiveSet$fRightReductiveSet$fLeftReductiveSet$fReductiveMaybe$fReductive(,,,)$fReductive(,,)$fReductive(,)$fRightReductiveProduct$fLeftReductiveProduct$fReductiveProduct$fReductiveDual $fReductive()$fLeftCancellativeText$fLeftCancellativeText0$fLeftCancellativeByteString$fLeftCancellativeByteString0$fLeftCancellativeVector$fLeftCancellativeSeq$fLeftCancellative[]$fLeftCancellative(,,,)$fLeftCancellative(,,)$fLeftCancellative(,)$fLeftCancellative()$fRightCancellativeText$fRightCancellativeText0$fRightCancellativeByteString$fRightCancellativeByteString0$fRightCancellativeVector$fRightCancellativeSeq$fRightCancellative[]$fRightCancellative(,,,)$fRightCancellative(,,)$fRightCancellative(,)$fLeftCancellativeDual$fRightCancellativeDual$fRightCancellative()$fCancellative(,,,)$fCancellative(,,)$fCancellative(,)$fCancellativeDual$fCancellative()$fRightCancellativeSum$fLeftCancellativeSum$fCancellativeSum$fRightReductiveSum$fLeftReductiveSum$fReductiveSum$fSumCancellativeNatural$fSumCancellativeRatio$fSumCancellativeInteger$fSumCancellativeIntOverlappingGCDMonoidstripPrefixOverlapstripSuffixOverlapoverlap stripOverlapMonus<\>$fOverlappingGCDMonoidText$fOverlappingGCDMonoidText0 $fOverlappingGCDMonoidByteString!$fOverlappingGCDMonoidByteString0$fOverlappingGCDMonoidVector$fOverlappingGCDMonoidSeq$fOverlappingGCDMonoid[]$fOverlappingGCDMonoidIntMap$fOverlappingGCDMonoidMap$fOverlappingGCDMonoidMaybe$fOverlappingGCDMonoid(,,,)$fOverlappingGCDMonoid(,,)$fOverlappingGCDMonoid(,)$fOverlappingGCDMonoidDual$fOverlappingGCDMonoid()$fOverlappingGCDMonoidIntSet $fMonusIntSet$fOverlappingGCDMonoidSet $fMonusSet $fMonusMaybe $fMonus(,,,) $fMonus(,,) $fMonus(,)$fOverlappingGCDMonoidProduct$fMonusProduct$fOverlappingGCDMonoidSum $fMonusSum $fMonusDual $fMonus()RightGCDMonoid commonSuffixstripCommonSuffix LeftGCDMonoid commonPrefixstripCommonPrefix GCDMonoidgcd$fLeftGCDMonoidText$fLeftGCDMonoidText0$fLeftGCDMonoidByteString$fLeftGCDMonoidByteString0$fLeftGCDMonoidVector$fLeftGCDMonoidSeq$fLeftGCDMonoid[]$fLeftGCDMonoidIntMap$fLeftGCDMonoidMap$fLeftGCDMonoidIntSet$fLeftGCDMonoidSet$fLeftGCDMonoidMaybe$fLeftGCDMonoid(,,,)$fLeftGCDMonoid(,,)$fLeftGCDMonoid(,)$fLeftGCDMonoid()$fRightGCDMonoidText$fRightGCDMonoidText0$fRightGCDMonoidByteString$fRightGCDMonoidByteString0$fRightGCDMonoidVector$fRightGCDMonoidSeq$fRightGCDMonoid[]$fRightGCDMonoidIntSet$fRightGCDMonoidSet$fRightGCDMonoidMaybe$fRightGCDMonoid(,,,)$fRightGCDMonoid(,,)$fRightGCDMonoid(,)$fLeftGCDMonoidDual$fRightGCDMonoidDual$fRightGCDMonoid()$fGCDMonoidIntSet$fGCDMonoidSet$fGCDMonoid(,,,)$fGCDMonoid(,,)$fGCDMonoid(,)$fRightGCDMonoidProduct$fLeftGCDMonoidProduct$fGCDMonoidProduct$fRightGCDMonoidSum$fLeftGCDMonoidSum$fGCDMonoidSum$fGCDMonoidDual $fGCDMonoid()RightCancellativeMonoidLeftCancellativeMonoidCancellativeMonoidRightReductiveMonoidLeftReductiveMonoidReductiveMonoidCommutativeMonoidStableFactorial Factorialfactors primePrefix primeSuffixfoldlfoldl'foldrlengthfoldMapreversemapMmapM_$fFactorialVector$fFactorialSet$fFactorialSeq$fFactorialIntSet$fFactorialIntMap$fFactorialMap$fFactorialText$fFactorialText0$fFactorialByteString$fFactorialByteString0 $fFactorial[]$fFactorial(,,,)$fFactorial(,,)$fFactorial(,)$fFactorialMaybe$fFactorialProduct$fFactorialSum$fFactorialDual $fFactorial()$fStableFactorialSum$fStableFactorialVector$fStableFactorialSeq$fStableFactorialText$fStableFactorialText0$fStableFactorialByteString$fStableFactorialByteString0$fStableFactorial[]$fStableFactorialDual$fStableFactorial()StableFactorialMonoidFactorialMonoidsplitPrimePrefixsplitPrimeSuffixinitstailsspanbreaksplit takeWhile dropWhile spanMaybe spanMaybe'splitAtdroptake$fFactorialMonoidVector$fFactorialMonoidSet$fFactorialMonoidSeq$fFactorialMonoidIntSet$fFactorialMonoidIntMap$fFactorialMonoidMap$fFactorialMonoidText$fFactorialMonoidText0$fFactorialMonoidByteString$fFactorialMonoidByteString0$fFactorialMonoid[]$fFactorialMonoid(,,,)$fFactorialMonoid(,,)$fFactorialMonoid(,)$fFactorialMonoidMaybe$fFactorialMonoidProduct$fFactorialMonoidSum$fFactorialMonoidDual$fFactorialMonoid() TextualMonoidfromText singletonsplitCharacterPrefixcharacterPrefixmap concatMaptoStringanyallscanlscanl1scanrscanr1 mapAccumL mapAccumRfindelemfoldl_foldl_'foldr_ takeWhile_ dropWhile_break_span_ spanMaybe_ spanMaybe_'$fTextualMonoidSeq$fTextualMonoidText$fTextualMonoidText0$fTextualMonoid[]$fTextualMonoidVector$fIsStringVectorStatefulextractstatesetState$fTextualMonoidStateful$fIsStringStateful$fStableFactorialStateful$fFactorialMonoidStateful$fFactorialStateful$fRightGCDMonoidStateful$fLeftGCDMonoidStateful$fRightReductiveStateful$fLeftReductiveStateful$fPositiveMonoidStateful$fMonoidNullStateful$fMonoidStateful$fSemigroupStateful$fApplicativeStateful$fFunctorStateful $fEqStateful $fOrdStateful$fShowStatefulLinePositionedlineOffsetPositionedpositioncolumn$fTextualMonoidOffsetPositioned$fIsStringOffsetPositioned!$fStableFactorialOffsetPositioned!$fFactorialMonoidOffsetPositioned$fFactorialOffsetPositioned $fRightGCDMonoidOffsetPositioned $fRightReductiveOffsetPositioned$fLeftGCDMonoidOffsetPositioned$fLeftReductiveOffsetPositioned $fPositiveMonoidOffsetPositioned$fMonoidNullOffsetPositioned$fMonoidOffsetPositioned$fSemigroupOffsetPositioned$fShowOffsetPositioned$fOrdOffsetPositioned$fEqOffsetPositioned$fPositionedOffsetPositioned$fApplicativeOffsetPositioned$fFunctorOffsetPositioned$fTextualMonoidLinePositioned$fIsStringLinePositioned$fStableFactorialLinePositioned$fFactorialMonoidLinePositioned$fFactorialLinePositioned$fRightGCDMonoidLinePositioned$fRightReductiveLinePositioned$fLeftGCDMonoidLinePositioned$fLeftReductiveLinePositioned$fPositiveMonoidLinePositioned$fMonoidNullLinePositioned$fMonoidLinePositioned$fSemigroupLinePositioned$fShowLinePositioned$fOrdLinePositioned$fEqLinePositioned$fPositionedLinePositioned$fApplicativeLinePositioned$fFunctorLinePositionedMeasuredmeasure$fTextualMonoidMeasured$fIsStringMeasured$fStableFactorialMeasured$fFactorialMonoidMeasured$fFactorialMeasured$fRightGCDMonoidMeasured$fLeftGCDMonoidMeasured$fRightReductiveMeasured$fLeftReductiveMeasured$fPositiveMonoidMeasured$fMonoidNullMeasured$fMonoidMeasured$fSemigroupMeasured $fOrdMeasured $fEqMeasured$fShowMeasuredConcat concatenateforce$fTextualMonoidConcat$fIsStringConcat$fStableFactorialConcat$fFactorialMonoidConcat$fFactorialConcat$fRightGCDMonoidConcat$fLeftGCDMonoidConcat$fRightReductiveConcat$fLeftReductiveConcat$fPositiveMonoidConcat$fMonoidNullConcat$fMonoidConcat$fSemigroupConcat$fFoldableConcat$fApplicativeConcat$fFunctorConcat $fOrdConcat $fEqConcat $fShowConcatByteStringUTF8decode$fTextualMonoidByteStringUTF8$fFactorialMonoidByteStringUTF8$fFactorialByteStringUTF8$fPositiveMonoidByteStringUTF8$fIsStringByteStringUTF8$fShowByteStringUTF8$fLeftGCDMonoidByteStringUTF8 $fLeftCancellativeByteStringUTF8$fLeftReductiveByteStringUTF8$fMonoidNullByteStringUTF8$fMonoidByteStringUTF8$fSemigroupByteStringUTF8$fEqByteStringUTF8$fOrdByteStringUTF8baseGHC.BaseMonoidmempty<>Data.Semigroup.InternalProduct Data.FoldableGHC.ListData.Traversable GHC.MaybeNothingJust Data.String fromString text-1.2.3.1Data.Text.InternalTextStringoffsetpuremappendbytestring-0.10.8.2Data.ByteString.Internal ByteString