h&ntb      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                     Trustworthy Vmonoid-subclasses Subclass of ? for types whose values have no inverse, with the exception of . 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&1monoid-subclassesHelper class to avoid FlexibleInstances3monoid-subclasses Subclass of 8 where : is a complete inverse of +, satisfying the following additional law:  stripSuffix b (a <> b) == Just a4monoid-subclasses Subclass of 8 where : is a complete inverse of +, satisfying the following additional law:  stripPrefix a (a <> b) == Just b5monoid-subclasses,Class of semigroups 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)8Every instance definition has to implement at least the 7 method.8monoid-subclasses+Class of semigroups 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)8Every instance definition has to implement at least the : method.;monoid-subclasses Subclass of < where =( is a complete inverse of the Semigroup  operation. The class instances must satisfy the following additional laws: 1(a <> b) a == Just b (a <> b) b == Just a<monoid-subclassesClass 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 : and 7, which must be equivalent as & is both associative and commutative. 1() = flip stripPrefix () = flip stripSuffix>monoid-subclassesO(n)?monoid-subclassesO(n)@monoid-subclassesO(n)Amonoid-subclassesO(n)Bmonoid-subclassesO(n)Cmonoid-subclasses!O(log(min(m,nDm)) + prefixLength)Dmonoid-subclassesO(prefixLength)Emonoid-subclassesO(m+n)Fmonoid-subclassesO(m+n)Kmonoid-subclassesO(1)Lmonoid-subclassesO(n)Mmonoid-subclassesO(n)Nmonoid-subclassesO(n)Omonoid-subclassesO(n)Pmonoid-subclassesO(n)Qmonoid-subclasses!O(log(min(m,nDm)) + suffixLength)Rmonoid-subclassesO(m+n)Smonoid-subclassesO(m+n)Tmonoid-subclassesO(m+n)[monoid-subclassesO(1)\monoid-subclassesO(m+n)]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/amonoid-subclasses O(m*log(nm + 1)), m <= n/bmonoid-subclasses|monoid-subclassesmonoid-subclassesO(1)monoid-subclassesO(1)monoid-subclassesO(1)123456789:;<=<=;1289:56743=5 Trustworthymonoid-subclassesClass 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 a1, in the sense that it contains any other value x that satifies the property (x 9 b) && (x 6 a): Dx. (x `isPrefixOf` b && x `isSuffixOf` a) => (x `isPrefixOf` overlap a b && x `isSuffixOf` overlap a b)0and it must be unique so there's no other value y3 that satisfies the same properties for every such x: Dy. ((Dx. (x `isPrefixOf` b && x `isSuffixOf` a) => x `isPrefixOf` y && x `isSuffixOf` y) => 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: not (x `isSuffixOf` a && x `isSuffixOf` b) || x `isSuffixOf` commonSuffix a b 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: not (x `isPrefixOf` a && x `isPrefixOf` b) || x `isPrefixOf` commonPrefix a b p && Just b' = b p where p = gcd a bIf a  happens to also be ;4, it should additionally satisfy the following laws: gcd (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), except on GHCjs where it is O(m+n)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-Inferred/+g"123456789:;<= Trustworthy3 monoid-subclassesA subclass of 7 whose instances satisfy the following additional laws: factors (a <> b) == factors a <> factors b factors . reverse == List.reverse . factors primeSuffix s == primePrefix (reverse s)monoid-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: maybe id sconcat . nonEmpty . factors == id List.all (\prime-> factors prime == [prime]) . factors primePrefix s == foldr const s 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 . 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 prime .monoid-subclassesLike  from  Data.List on the list of prime .monoid-subclassesLike  from  Data.List on the list of prime .monoid-subclassesThe  of the list of prime .monoid-subclasses Generalizes  from  Data.Foldable*, except the function arguments are prime % 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. Note that * is not considered a factor. 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"]The 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-subclassesSplits the argument into its prime prefix and the remaining suffix. Returns  for .monoid-subclassesSplits 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 prime .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.monoid-subclassesEquivalent to  from  Data.List.monoid-subclassesA stateful variant of , threading the result of the test function as long as it returns .monoid-subclassesStrict version of .monoid-subclassesLike  from  Data.List on the list of prime .monoid-subclassesEquivalent to  from  Data.List.monoid-subclassesEquivalent to  from  Data.List. Safe-InferredY$#monoid-subclassesThe  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: unfoldr 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  may contain non-character data insterspersed between its characters. Every class method that returns a modified  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: 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) toString undefined . fromString toText undefined . fromTextmonoid-subclasses(Contructs a new data type instance Like  , but from a  input instead of . $fromText == fromString . Text.unpackmonoid-subclasses5Creates a prime monoid containing a single character. singleton c == fromString [c]monoid-subclassesSpecialized version of . Every prime factor of a textual monoid must consist of a single character or no character at all.monoid-subclassesExtracts a single character that prefixes the monoid, if the monoid begins with a character. Otherwise returns . 2characterPrefix == fmap fst . splitCharacterPrefixmonoid-subclassesEquivalent to  from  Data.List with a  Char -> Char, function. Preserves all non-character data. "map f == concatMap (singleton . f)monoid-subclassesEquivalent to  from  Data.List with a Char -> String- function. Preserves all non-character data.monoid-subclassesReturns the list of characters the monoid contains, once the argument function converts all its non-character factors into characters.monoid-subclassesConverts the monoid into , given a function to convert the non-character factors into chunks of .monoid-subclassesEquivalent to  from  Data.List!. Ignores all non-character data.monoid-subclassesEquivalent to  from  Data.List!. Ignores all non-character data.monoid-subclassesThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent to  from  Data.List.monoid-subclassesStrict version of .monoid-subclassesThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent to 'List.foldl'' from  Data.List.monoid-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. (scanl f c == scanl1 f . (singleton c <>)monoid-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. (scanr f c == scanr1 f . (<> singleton c)monoid-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-subclassesThe first predicate tests the non-character data, the second one the characters. Otherwise equivalent to  from  Data.List when applied to a .monoid-subclassesThe 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 , threading the result of the test function as long as it returns .monoid-subclassesStrict version of .monoid-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.  b) ==  a +  b.monoid-subclasses Create a new  value.  Safe-Inferred6`Tmonoid-subclasses; is a transparent monoid transformer. The behaviour of the  a instances of monoid subclasses is identical to the behaviour of their a instances, up to the  isomorphism.The only purpose of  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). Safe-Inferred6bmonoid-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{|}~                                                                                                                     .monoid-subclasses-1.2.1-3yH7KPGzjEl7YvDRSDscr9Data.Semigroup.CancellativeData.Monoid.NullData.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.UTF85commutative-semigroups-0.1.0.0-HkbpDvIMO3p4f8x9QQA3opData.Semigroup.Commutative CommutativePositiveMonoid 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$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 concatMaptoStringtoTextanyallscanlscanl1scanrscanr1 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$fDataStateful $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$fFunctorLinePositioned$fDataLinePositioned$fDataOffsetPositionedMeasuredmeasure$fTextualMonoidMeasured$fIsStringMeasured$fStableFactorialMeasured$fFactorialMonoidMeasured$fFactorialMeasured$fRightGCDMonoidMeasured$fLeftGCDMonoidMeasured$fRightReductiveMeasured$fLeftReductiveMeasured$fPositiveMonoidMeasured$fMonoidNullMeasured$fMonoidMeasured$fSemigroupMeasured $fOrdMeasured$fDataMeasured $fEqMeasured$fShowMeasuredConcat concatenateforce$fTextualMonoidConcat$fIsStringConcat$fStableFactorialConcat$fFactorialMonoidConcat$fFactorialConcat$fRightGCDMonoidConcat$fLeftGCDMonoidConcat$fRightReductiveConcat$fLeftReductiveConcat$fPositiveMonoidConcat$fMonoidNullConcat$fMonoidConcat$fSemigroupConcat$fFoldableConcat$fApplicativeConcat$fFunctorConcat $fOrdConcat $fEqConcat $fDataConcat $fShowConcatByteStringUTF8decode$fTextualMonoidByteStringUTF8$fFactorialMonoidByteStringUTF8$fFactorialByteStringUTF8$fPositiveMonoidByteStringUTF8$fIsStringByteStringUTF8$fShowByteStringUTF8$fLeftGCDMonoidByteStringUTF8 $fLeftCancellativeByteStringUTF8$fLeftReductiveByteStringUTF8$fMonoidNullByteStringUTF8$fMonoidByteStringUTF8$fSemigroupByteStringUTF8$fDataByteStringUTF8$fEqByteStringUTF8$fOrdByteStringUTF8baseGHC.BaseMonoidmempty<>Data.Semigroup.InternalProduct Data.FoldableGHC.ListData.Traversable GHC.MaybeNothingJust Data.String fromString text-1.2.5.0Data.Text.InternalTextStringoffsetpuremappendbytestring-0.11.3.1Data.ByteString.Internal ByteString