!s      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                 TrustworthyD monoid-subclassesClass 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 bmonoid-subclassesClass 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 bmonoid-subclasses Subclass of   where   is a complete inverse of +, satisfying the following additional law:  stripSuffix b (a <> b) == Just amonoid-subclasses Subclass of   where   is a complete inverse of +, satisfying the following additional law:  stripPrefix a (a <> b) == Just bmonoid-subclasses)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. monoid-subclasses(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.monoid-subclassesClass 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 <> cmonoid-subclasses 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 amonoid-subclasses?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) == amonoid-subclasses[Class of all Abelian ({i.e.}, commutative) monoids that satisfy the commutativity property: a <> b == b <> a   5 TrustworthyL;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. Trustworthymonoid-subclassesA subclass of - whose instances satisfy this additional law: *factors (a <> b) == factors a <> factors bmonoid-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"]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.monoid-subclasses8Returns a list of all prime factors; inverse of mconcat.monoid-subclassesThe prime prefix,  if none.monoid-subclassesThe prime suffix,  if none.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-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-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.monoid-subclassesEquivalent to  from  Data.List.monoid-subclassesA stateful variant of B, 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 primes.monoid-subclassesEquivalent to  from  Data.List.monoid-subclassesEquivalent to  from  Data.List.monoid-subclassesEquivalent to  from  Data.List.monoid-subclassesA  equivalent.monoid-subclassesA  equivalent. Trustworthy;=߽"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: 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 . fromStringmonoid-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 TextualC monoid must consist of a single character or no character at all.monoid-subclassespExtracts 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, after having the argument function convert all its non-character factors into characters.monoid-subclassesEquivalent to  from  Data.List!. Ignores all non-character data.monoid-subclassesEquivalent to  from  Data.List!. Ignores all non-character data.monoid-subclassestThe first argument folds over the non-character prime factors, the second over characters. Otherwise equivalent to  from  Data.List.monoid-subclassesStrict version of .monoid-subclassestThe 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-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-subclassesI'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 .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. <split p == Factorial.split (maybe False p . characterPrefix)monoid-subclassesLike  from  Data.List when applied to a . Ignores non-character data.monoid-subclassesLike  from  Data.List when applied to a . Ignores non-character data.monoid-subclasses foldl_ = foldl constmonoid-subclasses takeWhile_ = takeWhile . constmonoid-subclasses dropWhile_ = dropWhile . constmonoid-subclasses break_ = break . constmonoid-subclasses span_ = span . constmonoid-subclasses )spanMaybe_ s = spanMaybe s (const . Just)%     %     SafeN"monoid-subclasses" 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."#$%&"#$%&Safef9monoid-subclassesthe current linemonoid-subclassesthe current offset=monoid-subclassesthe current column89:<;=:8;<9=Safebmonoid-subclassesb 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.dmonoid-subclasses Create a new b value.bcdbdcSafeYtmonoid-subclassest; 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).tuvwtuvw Nonemonoid-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.     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !""#$%&'()*+,-./0123456789#:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`#abcdefghijklmnopqr#stuvwxyz{|}~                     0monoid-subclasses-0.4.6.1-6sjKCaWbgmrLKaQ130DSEGData.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$fOrdByteStringUTF8baseGHC.Base<>mappendMonoidmemptyData.Semigroup.InternalProductNothing Data.FoldableGHC.ListJustData.Traversable Data.String fromString text-1.2.3.0Data.Text.InternalTextStringoffsetpurebytestring-0.10.8.2Data.ByteString.Internal ByteString