s`(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ `abcdefghijklmnopqrstuvwxyz{|}~ !!!"""""#####$$$$$$$$$$%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&''((((((((((((((((((((((((((((((((((( ( ( ( ( (())*++++++++++++++ +!+"+#,$,%,&-'.0/portable experimentalekmett@gmail.comnon-portable (MPTCs) experimentalekmett@gmail.com$This type may be best read infix. A c  m is a (01 m that maps  values of type c through unit to values of type m. A c- may also ) supply operations which tack-on another c to an existing (01 m on the left P or right. These specialized reductions may be more efficient in some scenarios $ and are used when appropriate by a  Generator . The names  and  work = by analogy to the synonymous operations in the list monoid. LThis class deliberately avoids functional-dependencies, so that () can be a c -Reducer  for all cJ, and so many common reducers can work over multiple types, for instance,  First and Last may reduce both a and )02 a . Since a  Generator has a fixed element Z type, the input to the reducer is generally known and extracting from the monoid usually Z is sufficient to fix the result type. Combinators are available for most scenarios where X this is not the case, and the few remaining cases can be handled by using an explicit  type annotation. Minimal definition:  or  Convert a value into a (01 Append a value to a (01$ for use in left-to-right reduction Prepend a value onto a (01( for use during right-to-left reduction Apply a  to a *03K container, after mapping the contents into a suitable form for reduction. Apply a  to a *03 mapping each element through  '+,-(./0123456789:;<=>?@ABCDE    non-portable (MPTCs) experimentalekmett@gmail.com "Provides a mechanism for the UTF8 (016 to report invalid characters to one or more monoids. *+,-(./0123456789:;<=>?@ABCDE    non-portable (MPTCs) experimentalekmett@gmail.com,+,-(./0123456789:;<=>?@ABCDE non-portable (MPTCs) experimentalekmett@gmail.comIf m is a c-Reducer , then m is (c  m)-Reducer ( This can be used to quickly select a Reducer for use as a F45  G45. *+,-(./0123456789:;<=>?@ABCDE The (01 ('unionWith mappend',)! for containers full of monoids. MPolymorphic containers that we can supply an operation to handle unions with The (01 (,) A Container suitable for the  (01 3+,-(./0123456789:;<=>?@ABCDE   portable experimentalekmett@gmail.coma ( transformer that treats H06 as I78  This lets you use a  ByteString as a I78 source without going through a (01 transformer like UTF8 "a (M transformer that asks only for the values contained in an indexed container %a (A transformer that asks only for the keys of an indexed container (minimal definition * or + -Apply a  directly to the elements of a ( 8+,-(./0123456789:;<=>?@ABCDE  !"#$%&'()*+,-./()*+,%&'"#$ !-./ ! !"#$#$%&'&'()*+,)*+,-./'non-portable (MPTCs, OverloadedStrings) experimentalekmett@gmail.com 0A (01: of partial information about locations in a source file. _ This is polymorphic in the kind of information you want to maintain about each source file. 1'We have an unhandled tab to deal with. 2We've only seen part of a line. 3We've seen some carriage returns. 4:An absolute position in a file is known, or an overriding #line directive has been seen 7?Compute the location of the next standard 8-column aligned tab 85lift information about a source file into a starting 0 for that file 9jextract partial information about the current column, even in the absence of knowledge of the source file :Fextract partial information about the current line number if possible ;<extract the standard format for an absolute source position 6+,-(./0123456789:;<=>?@ABCDE 0123456789:; 70432165:98; 04321123456789:;'non-portable (MPTCs, OverloadedStrings) experimentalekmett@gmail.com<A  & transformer that strips out newlines >A  6 transformer that strips out any character matched by J09 @A   transformer that breaks a I78 ( into distinct lines, feeding a I78  each line in turn. AA   transformer that breaks a I78 ( into distinct words, feeding a I78  each line in turn B#Extract the matched words from the A (01 C#Extract the matched lines from the @ (01 D^Utility function to extract words using accumulator, inside-word, and until-next-word monoids E^Utility function to extract lines using accumulator, inside-line, and until-next-line monoids 4+,-(./0123456789:;<=>?@ABCDE <=>?@ABCDE AB>?D@C<=E <==>??@ABCDE portable experimentalekmett@gmail.com*+,-(./0123456789:;<=>?@ABCDE FGHFGHFGHGH portable experimentalekmett@gmail.comKAn LZ78 compressing (, which supports efficient * operations Ja type-constrained - operation Kcontruct an LZ78-compressed ( using a L:;* internally, requires an instance of Ord. Lcontruct an LZ78-compressed (6 using a list internally, requires an instance of Eq. M*QuickCheck property: decode . encode = id N,QuickCheck property: decode . encodeEq = id >+,-(./0123456789:;<=>?@ABCDE  !"#$%&'()*+,-./IJKLMNIJKLMNIJKLMN (non-portable (overloaded strings, MPTCs) experimentalekmett@gmail.com*+,-(./0123456789:;<=>?@ABCDE OPQOPQOPQPQ #non-portable (type families, MPTCs) experimentalekmett@gmail.comRA generalization of Data.List.cycle to an arbitrary (019. May fail to terminate for some values in some monoids. SA generalization of Data.List.repeat to an arbitrary (019. May fail to terminate for some values in some monoids. TA generalization of Data.List.replicate to an arbitrary (01. Adapted from   Jhttp://augustss.blogspot.com/2008/07/lost-and-found-if-i-write-108-in.html RSTUSTRURSTU portable experimentalekmett@gmail.comVA ( which supports efficient ** operations over run-length encoded data. Y#A single run with a strict length. \<naive left to right encoder, which can handle infinite data ]*QuickCheck property: decode . encode = id B+,-(./0123456789:;<=>?@ABCDE  !"#$%&'()*+,-./VWXYZ[\]^_ VWXYZ[^\_] VWXWXYZZ[\]^_portable experimentalekmett@gmail.com`A (01 is just a M0<. with one object. This fakes that with a GADT aThe (017 of the endomorphisms over some object in an arbitrary M0<. d Extract the (01 from its representation as a M0< eConvert a value in a (01 into an arrow in a M0<. 2+,-(./0123456789:;<=>?@ABCDENOPQM `abcdeabc`de`abcbcdeportable experimentalekmett@gmail.com+,-(./0123456789:;<=>?@ABCDEfgfgfgportable experimentalekmett@gmail.com+,-(./0123456789:;<=>?@ABCDEfghhh"portable (but instances use MPTCs) experimentalekmett@gmail.comi Convert a (01 into a o . Mnemonic: Exp a * Exp b = Exp (a + b) l Convert a o into a (01 . Mnemonic: Log a + Log b = Log (a * b) '+,-(./0123456789:;<=>?@ABCDEfgijklmnopq opqlmnijk ijkjklmnmnopqpqportable experimentalekmett@gmail.com)+,-(./0123456789:;<=>?@ABCDEfghijklmnopqrrrportable (instances use MPTCs) experimentalekmett@gmail.coms (a + b) * c = (a * c) + (b * c)t a * (b + c) = (a * b) + (a * c)u0 annihilates q *+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuutsstunon-portable (MPTCs) experimentalekmett@gmail.comvA v is an instance of both o and (01 where  q distributes over f. ++,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuvvvwThe (01 (R0=,S02) over )02 a where S02 is the top element zThe (01 (T0=,S02) over )02 a where S02 is the bottom element }The (01 given by (R0=,U0>) The (01 (T0=,V0>) +-(wxyz{|}~}~z{|wxywxyxyz{|{|}~~-+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv experimentalekmett@gmail.comA v which adds V0> and U0> to a pre-existing type. A v using a type's built-in Bounded instance. 2+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuvThe v (R0=,W0>) over a extended with .  When aH has a Num instance with an addition that respects order, then this is S transformed into a tropical semiring. It is assumed that 0 is the least element  of a.  Ahttp://hal.archives-ouvertes.fr/docs/00/11/37/79/PDF/Tropical.pdf 1+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv2+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstu?portable experimentalekmett@gmail.com,+,-(./0123456789:;<=>?@ABCDEfghijklmnopqrstuportable experimentalEdward Kmett <ekmett@gmail.com>Minimal complete definition:  or  "+,-(./0123456789:;<=>?@ABCDEfgportable experimentalekmett@gmail.com$+,-(./0123456789:;<=>?@ABCDEfgportable experimentalekmett@gmail.com"Minimal definition over or grecip x / y x  y/+,-(./0123456789:;<=>?@ABCDEfgijklmnopqportable experimentalekmett@gmail.com&+,-(./0123456789:;<=>?@ABCDEfghportable experimentalekmett@gmail.com7+,-(./0123456789:;<=>?@ABCDEfghijklmnopqrportable (instances use MPTCs) experimentalekmett@gmail.com0+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv non-portable (MPTCs) experimentalekmett@gmail.com3+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv!non-portable (MPTCs) experimentalekmett@gmail.com3+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv"?non-portable (MPTCs, scoped types, empty decls, type operators) experimentalEdward Kmett <ekmett@gmail.com>5+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv#non-portable (MPTCs) experimentalekmett@gmail.com  (x *. m) .* y = x *. (m .* y)  (m .* x) * y = m .* (x * y)  (x * y) *. m = x * (y *. m)5+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv$non-portable (MPTCs) experimentalekmett@gmail.comif m is a # over r and f is a X0@ then f $$ m is a # over r as well A $$ turns any Y0@ instance into a (01.  It also provides a o instance for an X0@ functor wrapped around a (01  and asserts that any Y0@ applied to a (01 forms a s  under these operations. A $$ uses an glues together X0@ actions with (*>)  in the manner of  traverse_ from  Data.Foldable. Any values returned by " reduced actions are discarded. 2Efficiently avoid needlessly rebinding when using & on an action that already returns () ; A rewrite rule automatically applies this when possible J+,-(./0123456789:;<=>?@ABCDE fgijklmnopqstuv %non-portable (MPTCs) experimentalekmett@gmail.comif m is a # over r and f is a Z0A then f %% m is a # as well A %% turns any [0A instance into a (01.  It also provides a o instance for a Z0A wrapped around a (01  and asserts that any [0A applied to a (01 forms a s  under these operations. An %% uses glues together Z0A actions with (>>)  in the manner of \0A from  Data.Foldable. Any values returned by " reduced actions are discarded. 2Efficiently avoid needlessly rebinding when using & on an action that already returns () ; A rewrite rule automatically applies this when possible ?+,-(./0123456789:;<=>?@ABCDE fgijklmnopqstu &#non-portable (type families, MPTCs) experimentalekmett@gmail.com Efficiently * a ( using the $$4 monoid. A specialized version of its namesake from  Data.Foldable   * $ !Convenience function as found in  Data.Foldable   ]0> & 1The sum of a collection of actions, generalizing ^0B   / $  Efficiently * a ( using the %%4 monoid. A specialized version of its namesake from  Data.Foldable and  Control.Monad   . % !Convenience function as found in  Data.Foldable and  Control.Monad   ]0> & 1The sum of a collection of actions, generalizing ^0B   / %  Efficiently * a ( using the G F 4 monoid. A specialized version of its namesake from  Data.Foldable   . H  Type specialization of foldMap above  Efficiently - a ( using the G F 4 monoid. A specialized version of its namesake from  Data.Foldable   / H   Convert any (. to a list of its contents. Specialization of -  Efficiently - a ( that contains values of type _7C   / 401  Efficiently - a ( that contains values of type _7C   / 701  Efficiently * any (C checking to see if any of its values match the supplied predicate   . 701  Efficiently * any (C checking to see if all of its values match the supplied predicate   . 401 (Efficiently sum over the members of any (   / :01 2Efficiently take the product of every member of a (   / =01 Check to see if & member of the ( matches the supplied value BCheck to make sure that the supplied value is not a member of the (  Efficiently * a subset of the elements in a ( jAllows idiomatic specialization of filter by proving a function that will be used to transform the output A specialization of & using the A01B01 (01, analogous to Data.List.find   & @01 M+,-(./0123456789:;<=>?@ABCDE  !"#$%&'()*+,-./'non-portable (MPTCs) experimentalekmett@gmail.com:+,-(./0123456789:;<=>?@ABCDE  !"#$%&'()*+,-./(*`A set of values a. O(n+m). See (. O(1). Is this the empty set? O(1)%. The number of elements in the set. O(log n). Is the element in the set? O(log n)!. Is the element not in the set? O(1). The empty set. O(1). Create a singleton set. O(log n). Insert an element in a set. B If the set already contains an element equal to the given value, $ it is replaced with the new value. O(log n) . Delete an element from a set. O(n+m)9. Is this a proper subset? (ie. a subset but not equal). O(n+m). Is this a subset?  (s1 ( s2) tells whether s1 is a subset of s2. O(log n) . The minimal element of a set. O(log n) . The maximal element of a set. O(log n). Delete the minimal element. O(log n). Delete the maximal element. The union of a list of sets: (( == a0B ( (). O(n+m)7. The union of two sets, preferring the first set when ! equal elements are encountered. ' The implementation uses the efficient  hedge-union algorithm. * Hedge-union is more efficient on (bigset ( smallset). O(n+m). Difference of two sets. & The implementation uses an efficient hedge algorithm comparable with  hedge-union. O(n+m) . The intersection of two sets. @ Elements of the result come from the first set, so for example   import qualified Data.Set as S  data AB = A | B deriving Show ( instance Ord AB where compare _ _ = EQ $ instance Eq AB where _ == _ = True = main = print (S.singleton A `S.intersection` S.singleton B, = S.singleton B `S.intersection` S.singleton A) prints  (fromList [A] ,fromList [B]). O(n)2. Filter all elements that satisfy the predicate. O(n)F. Partition the set into two sets, one with all elements that satisfy 1 the predicate and one with all elements that don't satisfy the predicate.  See also (.  O(n*log n).  ( f s! is the set obtained by applying f to each element of s. It'>s worth noting that the size of the result may be smaller if,  for some (x,y), x /= y && f x == f y O(n). The ( f s == ( f s, but works only when f is monotonic.   The precondition is not checked.  Semi-formally, we have: / and [x < y ==> f x < f y | x <- ls, y <- ls] 5 ==> mapMonotonic f s == map f s  where ls = toList s O(n);. Fold over the elements of a set in an unspecified order. bO(n). Post-order fold. O(n). The elements of a set. O(n)). Convert the set to a list of elements. O(n)4. Convert the set to an ascending list of elements.  O(n*log n)(. Create a set from a list of elements. O(n)5. Build a set from an ascending list in linear time.  :The precondition (input list is ascending) is not checked. O(n)J. Build a set from an ascending list of distinct elements in linear time.  CThe precondition (input list is strictly ascending) is not checked. O(log n). The expression (( x set ) is a pair  (set1,set2)  where set1 comprises the elements of set less than x and set2  comprises the elements of set greater than x. O(log n) . Performs a ($ but also returns whether the pivot ( element was found in the original set. cO(log n) . Performs a ( but also returns the pivot - element that was found in the original set. O(log n)'. Delete and find the minimal element. 2 deleteFindMin set = (findMin set, deleteMin set)  O(log n)'. Delete and find the maximal element. 2 deleteFindMax set = (findMax set, deleteMax set)  O(log n)4. Retrieves the minimal key of the set, and the set  stripped of that element, or S02 if passed an empty set.  O(log n)4. Retrieves the maximal key of the set, and the set  stripped of that element, or S02 if passed an empty set.  O(n);. Show the tree that implements the set. The tree is shown " in a compressed, hanging format.  O(n). The expression (showTreeWith hang wide map) shows & the tree that implements the set. If hang is  True, a hanging5 tree is shown otherwise a rotated tree is shown. If  wide is d7C", an extra wide version is shown. F Set> putStrLn $ showTreeWith True False $ fromDistinctAscList [1..5]  4  +--2  | +--1  | +--3  +--5  E Set> putStrLn $ showTreeWith True True $ fromDistinctAscList [1..5]  4  |  +--2  | |  | +--1  | |  | +--3  |  +--5  F Set> putStrLn $ showTreeWith False True $ fromDistinctAscList [1..5]  +--5  |  4  |  | +--3  | |  +--2  |  +--1 O(n)/. Test if the internal set structure is valid. )     )     )     )#non-portable (type families, MPTCs) experimentalekmett@gmail.com-+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv*#Algebra over a (near) (semi) ring.  *r *. (x * y) = (r *. x) * y = x * (r *. y) *(x * y) .* r = y * (x .* r) = (y .* r) * x6+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv+portable (instances use MPTCs) experimentalekmett@gmail.com"vSet operations optimized for tightly grouped sets or nearly universal sets with a close by group of elements missing. w Stores itself like an arbitrary precision floating point number, tracking the least valued member of the set and an & Integer comprised of the members. e1A conservative upper bound on the element count. A If negative, we are complemented with respect to the universe f1A conservative lower bound on the element count. A If negative, we are complemented with respect to the universe gKLazy element count used when the above two disagree. O(1) environment size hCLow water mark. index of the least element potentially in the set. iGHigh water mark. index of the greatest element potentially in the set. j,the set of bits starting from the exponent. C if negative, then we are complmenented with respect to universe kinvariant: whenever mantissa <5 0, universe = (fromEnum minBound,fromEnum maxBound) l5self-contained extraction behavior, enables Foldable mEInternal smart constructor. Forces count whenever it is pigeonholed. nO(d) where d> is absolute deviation in the output of fromEnum over the set O(1) The empty set. Permits O(1) null and size. O(1) Construct a BitSet with a single element. Permits O(1) null and size O(1) amortized cost. Is the +' empty? May be faster than checking if + == 0. O(1)8 amortized cost. The number of elements in the bit set. O(d) A +/ containing every member of the enumeration of a. O(d) Complements a + with respect to the bounds of a. Preserves order of + and + oO(d)\ unsafe internal method: complement a set that has already been complemented at least once. pO(d)\ unsafe internal method: complement a set that has already been complemented at least once. O(d * n) Make a + from a list of items. O(d * n) Make a +) from a distinct ascending list of items O(d)! Insert a single element of type a into the +. Preserves order of + and + O(d) Delete a single item from the +. Preserves order of + and + O(1) Test for membership in a + O(d)B convert to an Integer representation. Discards negative elements O(d).  O(1)6 Check to see if we are represented as a complemented +. !O(d) qSUnsafe internal method for computing differences in a known universe of discourse. Preconditions:  m >= 0  2 m' >= 0  3 a /= -1  4 a' /= -1  5 b /= 0  6 b' /= 0  7 u''" is a previously obtained copy of &(fromEnum minBound, fromEnum maxBound) rO(d)A Remove all elements present in the second bitset from the first "O(d) Infix r s8Utility function to avoid requiring ScopedTypeVariables tO(d) uO(d)O. Computes the equivalent of (truncate . logBase 2 . abs) extended with 0 at 0 G+,-(./0123456789:;<=>?@ABCDE fgijklmnopqstuv !"!"  !",portable (instances use MPTCs) experimentalekmett@gmail.com8+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv#$%#%$#$%-portable experimentalekmett@gmail.com5+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv&&&.;+,-(./0123456789:;<=>?@ABCDEfgijklmnopqstuv&'''vDEFGHIJKLMNOPQRSTTUVVWXYZ[[\]^_``abbcddefghijklmnopqrstuvwxyz{|}q~          ^   !!!"""""#####$$$$$$$$$$%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&''((((((( (^(( ( ( ( ((((((_((((((((((((((((( (!("(#($(%)&)'*(+)+^++++*+++++ + ++,+_+-++,.,/,0-1.201302403501601701801901:01:01;01<01<01=01>01>01?01@01@01A01B01B01C01D01D01E01F01F01G01H01H45I45J0KL78M0NO P:;Q0<R0<S0<T0<U0<V0WX02Y0WZ0[\0[]0^0@_0@`0ab0Ac0A0ad0ef7Cg(h0ei(j(k7Cl+m+n+o+p+q+r+s+t+u++v+w+x++y+z+{|monoids-0.1.33Data.Monoid.ReducerData.Monoid.Reducer.Char Data.Monoid.Lexical.UTF8.DecoderData.Monoid.Reducer.WithData.Monoid.UnionData.Generator"Data.Monoid.Lexical.SourcePositionData.Monoid.Lexical.WordsData.Monoid.SelfData.Generator.Compressive.LZ78Data.Monoid.FromStringData.Monoid.CombinatorsData.Generator.Compressive.RLEData.Monoid.CategoricalData.Monoid.AdditiveData.Monoid.Additive.SugarData.Monoid.Multiplicative Data.Monoid.Multiplicative.SugarData.Ring.Semi.NearData.Ring.SemiData.Monoid.OrdData.Ring.Semi.KleeneData.Ring.Semi.OrdData.Ring.Semi.TropicalData.Ring.Semi.Near.Trie Data.GroupData.Group.CombinatorsData.Group.MultiplicativeData.Group.SugarData.Group.Multiplicative.Sugar Data.RingData.Ring.BooleanData.Ring.FromNumData.Ring.ModularArithmeticData.Ring.ModuleData.Monoid.ApplicativeData.Monoid.MonadData.Generator.CombinatorsData.Generator.FreeData.Set.UnboxedData.Ring.Semi.NaturalData.Ring.AlgebraData.Ring.Semi.BitSet)Data.Ring.Module.AutomaticDifferentiation Data.FieldData.Field.VectorSpaceData.Monoid.Instancesbase Data.Monoid Data.Maybe Data.Foldablefingertree-0.0Data.FingerTree Data.Wordghc-prim GHC.Types Data.Charcontainers-0.2.0.1Data.MapControl.CategoryData.OrdPreludeData.Ring.SugarControl.Applicative Control.Monad Data.ListGHC.Bool ReducedBy Reduction getReductionReducerunitsnoccons foldMapReduce foldReduce returnUnitpureUnit CharReducerfromChar invalidCharUTF8runUTF8 WithReducerwithoutReducer UnionWith getUnionWith HasUnionWith unionWith emptyWithUniongetUnionHasUnionemptyunionChar8getChar8Values getValuesKeysgetKeys GeneratorElem mapReducemapTomapFromreduce mapReduceWith reduceWithSourcePositionTabColumnsLinesPos SourceColumn SourceLinenextTab startOfFile sourceColumn sourceLineshowSourcePositionUnlined runUnlinedUnspaced runUnspacedWordsrunWordsrunLines wordsFrom linesFromSelfgetSelfLZ78decodeencodeencodeEqprop_decode_encodeprop_decode_encodeEq FromString getFromStringcyclerepeat replicate!prop_replicate_right_distributiveRLEgetRLERun encodeListprop_decode_encodeListCMonoidGEndogetGEndocategoryToMonoidmonoidToCategorypluszero+ExpgetExpLoggetLogMultiplicativeonetimes*RightSemiNearRingLeftSemiNearRingRingoidSemiRing MinPrioritygetMinPriority MaxPrioritygetMaxPriorityMingetMinMaxgetMax minfinityinfinity KleeneAlgebrastarPriorityMaxBoundMinBoundOrdergetOrderTropical getTropicalTrietotallabelchildren singletonnullGroupgnegateminus gsubtractMultiplicativeGroupoverundergrecip-negatesubtract/\\recipRingBoolRing getBoolRingFromNum getFromNumModularmodulusModgetModwithIntegralModulusModule RightModule.* LeftModule*.AppgetAppAltgetAlt Traversal getTraversal snocTraversalMongetMonMonadSum getMonadSumAction getAction snocAction traverse_for_asummapM_forM_msumfoldMap concatMapfoldtoListandoranyallsumproductelemnotElemfilter filterWithfindFree AnyGeneratorUSUSetsizemember notMemberinsertdeleteisProperSubsetOf isSubsetOffindMinfindMax deleteMin deleteMaxunions difference intersection partitionmap mapMonotonicelems toAscListfromList fromAscListfromDistinctAscListsplit splitMember deleteFindMin deleteFindMaxminViewmaxViewshowTree showTreeWithvalidNaturalnaturalRAlgebraBitSetfull complement toIntegerisComplementedDliftdField VectorSpaceMonoidMaybeFoldablemappendmconcatmemptygetDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProductgetFirstFirstgetLastLast FingerTreemeasureGHC.WordWord8Char GHC.UnicodeisSpaceTokenMapCategory>>><<<.id GHC.ClassesminNothingmaxGHC.EnummaxBoundminBoundGHC.Num Applicative AlternativeGHC.BaseMonad MonadPlusflipGHC.ListconcatBoolSetfoldlfoldr splitLookupTrue _countAtLeast _countAtMost_countexponent_hwmmantissa _universe _fromEnumbs recomplementpseudoComplementdiff asArgTypeOfrecounthwm