1z      !"#$%&'( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy Safe-Inferred'Show a value using an infix operator.  Safe-Inferred.Parse a string containing an infix operator. #Compose two parsers sequentially.  Safe-Inferred     Safe-Inferred     Safe-Inferred &Also present in newer versions of the base package. Monadic . /repeat action until result fulfills condition /repeat action until result fulfills condition !parameter order equal to that of nest !parameter order equal to that of nest Lazy monadic conjunction. 'That is, when the first action returns False, then False= is immediately returned, without running the second action. Lazy monadic disjunction. 'That is, when the first action returns True, then True= is immediately returned, without running the second action.     Safe-InferredCf. '(Control.Arrow.***)'. 7Apply two functions on corresponding values in a pair, 9where the pattern match on the pair constructor is lazy. -This is crucial in recursions such as the of  partition.    !" !" !" !" Safe-Inferred#Generalization of  to any monoid. $Infix synonym for ' mappend. #$#$#$#$ Safe-Inferred%Returns z$ if the precondition is fulfilled. &This is an infix version of {  for writing  style expressions #using test functions, that produce |s. +The precedence is chosen to be higher than '(:)', in order to allow:   alternatives default $  checkForA ?-> (\a -> f a) :  checkForB ?-> (\b -> g b) :  [] "The operation is left associative in order to allow to write   checkForA ?-> f ?-> g which is equivalent to   checkForA ?-> g . f due to the functor law. %&'%&'%&'%&'  Safe-Inferred()*+,-()*+,-()*+,-()*+,- Safe-Inferred.#Compositional power of a function, i.e. apply the function n times to a value. It is rather the same as iter in Simon Thompson: "#The Craft of Functional Programming" , page 172 }#Compositional power of a function, i.e. apply the function n times to a value. It is rather the same as iter in Simon Thompson: "#The Craft of Functional Programming" , page 172 ~#Compositional power of a function, i.e. apply the function n times to a value. It is rather the same as iter in Simon Thompson: "#The Craft of Functional Programming" , page 172 /powerAssociative is an auxiliary function that, for an associative operation op, computes the same value as  ?powerAssociative op a0 a n = foldr op a0 (genericReplicate n a) but applies op' O(log n) times and works for large n. powerAssociative is an auxiliary function that, for an associative operation op, computes the same value as  ?powerAssociative op a0 a n = foldr op a0 (genericReplicate n a) but applies op' O(log n) times and works for large n. Flipped version of '($)'. It was discussed as (&) in http:www.haskell.org pipermail libraries 2012-November 018832.html  I am not sure, that we need it. It is not exported for now. .}~/.}~/.}~/  Safe-Inferred0 Known as on in newer versions of the base package. 0./0./00 Safe-Inferred1@Divides a list into sublists such that the members in a sublist share the same key. It uses semantics of ,  not that of . Will be less efficient than 1 if key is computationally expensive. ?This is so because the key is re-evaluated for each list item. Alternatively you may write groupBy ((==) on key). 2argmin 3argmax 123456123456123456  Safe-Inferred123456642315  Safe-Inferred8limit (lower,upper) x restricts x to the range from lower to upper. Don't expect a sensible result for  lower>upper. 9limit (lower,upper) x checks whether x is in the range from lower to upper. Don't expect a sensible result for  lower>upper. 789789789789  Safe-Inferred:::: Safe-Inferred; if-then-else as function.  Example:  if' (even n) "even" $  if' (isPrime n) "prime" $  "boring" < The same as ;, but the name is chosen $such that it can be used for GHC-7.0'"s rebindable if-then-else syntax. =+From a list of expressions choose the one, whose condition is true.  Example:  select "boring" $  (even n, "even") :  (isPrime n, "prime") :  [] +From a list of expressions choose the one, whose condition is true.  Example:  select "boring" $  (even n, "even") :  (isPrime n, "prime") :  [] +From a list of expressions choose the one, whose condition is true.  Example:  select "boring" $  (even n, "even") :  (isPrime n, "prime") :  [] > Like the ?( operator of the C progamming language.  Example:  bool ?: (yes, no). ?"Logical operator for implication. #Funnily because of the ordering of  it holds  implies == (<=). ;<=>?;<=>?;<=>? Safe-Inferred;<=>?;<=>? Safe-Inferred @$Make a list as long as another one A1Drop as many elements as the first list is long  laxTail [] = []CHCheck whether two lists with different element types have equal length. It is equivalent to length xs == length ys but more efficient. D6Compare the length of two lists over different types. It is equivalent to !(compare (length xs) (length ys)) but more efficient. "this one uses explicit recursion strict comparison ElessOrEqualLength x y is almost the same as compareLength x y <= EQ, but lessOrEqualLength [] undefined = True, whereas compareLength [] undefined <= EQ = undefined. F&Returns the shorter one of two lists. 6It works also for infinite lists as much as possible. E.g. 6shorterList (shorterList (repeat 1) (repeat 2)) [1,2,3] can be computed. 6The trick is, that the skeleton of the resulting list is constructed using  without touching the elements. 3The contents is then computed (only) if requested. This lazier than F in a different aspect: It returns a common prefix 8even if it is undefined, which list is the shorter one. However, it requires a proper  instance 9and if elements are undefined, it may fail even earlier. @ABCDEFG@ABCDEFG@ABCDEFG  Safe-Inferred0HIThis function is lazier than the one suggested in the Haskell 98 report. It is inits undefined = [] : undefined, in contrast to %Data.List.inits undefined = undefined. 3Suggested implementation in the Haskell 98 report. It is not as lazy as possible. IIThis function is lazier than the one suggested in the Haskell 98 report. It is tails undefined = ([] : undefined) : undefined, in contrast to %Data.List.tails undefined = undefined. J4This function compares adjacent elements of a list. UIf two adjacent elements satisfy a relation then they are put into the same sublist.  Example:  1 groupBy (<) "abcdebcdef" == ["abcde","bcdef"] In contrast to that  compares ?the head of each sublist with each candidate for this sublist.  This yields  3 List.groupBy (<) "abcdebcdef" == ["abcdebcdef"]  The second b is compared with the leading a. (Thus it is put into the same sublist as a. The sublists are never empty. +Thus the more precise result type would be [(a,[a])]. LLike standard L but more lazy. It is &Data.List.unzip undefined == undefined, but )unzip undefined == (undefined, undefined). M!' of GHC 6.2.1 fails on infinite lists. But this one does not. NIt is &Data.List.span f undefined = undefined, whereas )span f undefined = (undefined, undefined). OIt is &Data.List.span f undefined = undefined, whereas )span f undefined = (undefined, undefined). PASplit the list at the occurrences of a separator into sub-lists. Remove the separators. $This is somehow a generalization of  and . But note the differences:  $ Prelude Data.List.HT> words "a a"  ["a","a"] + Prelude Data.List.HT> chop (' '==) "a a"  ["a","","a"]  & Prelude Data.List.HT> lines "a\n\na"  ["a","","a"] . Prelude Data.List.HT> chop ('\n'==) "a\n\na"  ["a","","a"] # Prelude Data.List.HT> lines "a\n"  ["a"] + Prelude Data.List.HT> chop ('\n'==) "a\n"  ["a",""] QLike O), but splits after the matching element. R5Split the list after each occurence of a terminator. Keep the terminator. ?There is always a list for the part after the last terminator. It may be empty. S=Split the list before each occurence of a leading character. Keep these characters. HThere is always a list for the part before the first leading character. It may be empty. T removeEach xs" represents a list of sublists of xs, where each element of xs is removed and "the removed element is separated. ,It seems to be much simpler to achieve with %zip xs (map (flip List.delete xs) xs), but the implementation of T does not need the  instance 2and thus can also be used for lists of functions. See also the proposal   Dhttp://www.haskell.org/pipermail/libraries/2008-February/009270.html V It holds "splitLast xs == (init xs, last xs), but V is more efficient 8if the last element is accessed after the initial ones, "because it avoids memoizing list. WShould be prefered to  and . XShould be prefered to  and . YShould be prefered to  and . ZShould be prefered to  and . [4Remove the longest suffix of elements satisfying p. In contrast to reverse . dropWhile p . reverse $this works for infinite lists, too. \Alternative version of reverse . takeWhile p . reverse. Doesn'3t seem to be superior to the naive implementation.  However it is more inefficient, 5because of repeatedly appending single elements. :-( ]maybePrefixOf xs ys is Just zs if xs is a prefix of ys, where zs is ys without the prefix xs. Otherwise it is Nothing. ^1Partition a list into elements which evaluate to Just or Nothing by f.  It holds $mapMaybe f == fst . partitionMaybe f and partition p == partitionMaybe ( x -> toMaybe (p x) x). _This is the cousin of  analogously to  being the cousin of . @Example: Keep the heads of sublists until an empty list occurs. + takeWhileJust $ map (fmap fst . viewL) xs a%keep every k-th value from the list %keep every k-th value from the list %keep every k-th value from the list %keep every k-th value from the list 7This is slightly wrong, because it re-replaces things.  That'$s also the reason for inefficiency: P The replacing can go on only when subsequent replacements are finished. 2 Thus this functiob fails on infinite lists. g Transform  " [[00,01,02,...], [[00], % [10,11,12,...], --> [10,01], ( [20,21,22,...], [20,11,02], ! ...] ...] With concat . shear+ you can perform a Cantor diagonalization, 8that is an enumeration of all elements of the sub-lists Awhere each element is reachable within a finite number of steps. ?It is also useful for polynomial multiplication (convolution). It's somehow inverse to zipCons, but the difficult part is, <that a trailing empty list on the right side is suppressed. h Transform  " [[00,01,02,...], [[00], % [10,11,12,...], --> [01,10], ( [20,21,22,...], [02,11,20], ! ...] ...] It's like g8 but the order of elements in the sub list is reversed. ;Its implementation seems to be more efficient than that of g. ,If the order does not matter, better choose h. zipCons is like  zipWith (:)' but it keeps lists which are too long This version works also for zipCons something undefined. zipCons' is like  zipWith (:)' but it keeps lists which are too long iJOperate on each combination of elements of the first and the second list. $In contrast to the list instance of "# )in holds the results in a list of lists.  It holds 1concat (outerProduct f xs ys) == liftM2 f xs ys j"Take while first predicate holds, 3then continue taking while second predicate holds,  and so on. This is a combination of  and  in the sense of . It is however more efficient Gbecause it avoids storing the whole input list as a result of sharing. This is a combination of  and  in the sense of . It is however more efficient Gbecause it avoids storing the whole input list as a result of sharing. This is a combination of  and  in the sense of . It is however more efficient Gbecause it avoids storing the whole input list as a result of sharing. l rotate left 'more efficient implementation of rotate'  rotate left  rotate left m!Given two lists that are ordered (i.e. p x y holds for subsequent x and y) m* them into a list that is ordered, again. q8This function combines every pair of neighbour elements #in a list with a certain function. r Enumerate without Enum context. !For Enum equivalent to enumFrom. uFor an associative operation op this computes  *iterateAssociative op a = iterate (op a) a but it is even faster than "map (powerAssociative op a a) [0..] #since it shares temporary results.  The idea is: From the list (map (powerAssociative op a a) [0,(2*n)..] we compute the list $map (powerAssociative op a a) [0,n..], and iterate that until n==1. vThis is equal to u. The idea is the following: 4The list we search is the fixpoint of the function: sSquare all elements of the list, then spread it and fill the holes with successive numbers of their left neighbour. 2This also preserves log n applications per value. However it has a space leak, !because for the value with index n all elements starting at div n 2 must be kept. pHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvpHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvpHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv Safe-Inferred/HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv/HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijlmnopqrstuvk$ Safe-Inferredw?Lexicographically compare a list of attributes of two records.  Example: ( compare [comparing fst, comparing snd] x@Check whether a selected set of fields of two records is equal.  Example: $ equal [equating fst, equating snd] wxwxwx Safe-Inferredwxwx Safe-Inferredy#remove leading and trailing spaces yyyy Safe-Inferred@ABCDEFG@ABGCDEF%&'()*+,-./01234567089:;<=>?@ABCDEFGHI J K L M N OPQ RSTUVWX Y Z M [\]^_`abcdefg h i  S j ! k l m n o p q r s t u v w x y z { | } ~  J $$         $$ utility-ht-0.0.9 Text.Show.HT Text.Read.HTData.Strictness.HTControl.Functor.HTControl.Monad.HT Data.Tuple.HTData.Monoid.HT Data.Maybe.HT Data.Ix.EnumData.Function.HT Data.List.Key Data.Ord.HT Data.Eq.HT Data.Bool.HTData.List.Match Data.List.HTData.Record.HTData.String.HTListrepeat Control.Arrowfirstsecond Data.ListcycleselectData.Function.HT.PrivateData.List.Key.PrivategroupByData.Bool.HT.PrivateData.List.Match.PrivateData.List.HT.Private partitionMonadliftM2Data.Record.HT.PrivateshowsInfixPrecconcatSreadsInfixPrec.>readMany maybeRead arguments1 arguments2 arguments3 arguments4 arguments5void<=<untilMuntil iterateLimitM iterateLimitandLazyorLazymapPairmapFstmapSndswap forcePairfst3snd3thd3 mapTriplemapFst3mapSnd3mapThd3curry3uncurry3<>toMaybe?-> alternativesrangeindex unsafeIndexinRange rangeSizeunsafeRangeSizenestpowerAssociativecompose2groupminimummaximumsortmergenub comparinglimitequatingif' ifThenElse?:impliestakedropsplitAt equalLength compareLengthlessOrEqualLength shorterList replicateinitstailsunzipspanbreakchop breakAfter segmentAfter segmentBefore removeEachsplitEverywhere splitLastviewLviewRswitchLswitchR dropWhileRev takeWhileRev maybePrefixOfpartitionMaybe takeWhileJust unzipEitherssievesliceHorizontal sliceVerticalsearchreplace multiReplaceshearshearTranspose outerProducttakeWhileMulti lengthAtLeastrotatemergeByallEqual isAscendingisAscendingLazy mapAdjacentpadLeftpadRightiterateAssociative iterateLeakycompareequaltrimbase Data.MaybeJustGHC.BasefmapMaybenest1nest2powerAssociative1$%propNestgroup'attachauxaux' propGroupgroupByNonEmpty groupByEmptyselect0select1ghc-prim GHC.TypesBoolzipIflaxTailcompareLength0compareLength1GHC.ListzipWith shorterListEq GHC.ClassesEqdropRecdrop0drop1drop2laxTail0inits98lineswordsheadtailinitlast takeWhileRev'takeWhileRev'' takeWhile catMaybesfiltersieve'sieve''sieve''' replace'' unzipConsSkewzipConszipCons'foldl'rfoldl'foldr propFoldl'r foldl'rStrict foldl'rNaiverotate'rotate''inits98'tails'tails98chop' chopAtRunpropSegmentAfterConcatpropSegmentAfterNumSepspropSegmentAfterLastspropSegmentAfterInitspropSegmentAfterInfinitesegmentBefore'segmentBefore''propSegmentBeforeConcatpropSegmentBeforeNumSepspropSegmentBeforeHeadspropSegmentBeforeTailspropSegmentBeforeInfinitepropSegmentBeforeGroupBy0propSegmentBeforeGroupBy1 propSplitLast propViewRswitchL' propSwitchR dropWhileRev' propSievesliceHorizontal'sliceHorizontal''sliceHorizontal'''propSliceHorizontalsliceVertical'propSliceVertical propSlice markSublistsreplace' propReplaceIdpropReplaceCycle multiReplace'propMultiReplaceSingle transposeFill unzipConsshear' zipConsSkewtakeWhileMulti'propTakeWhileMultiiterateUntilCycleiterateUntilCyclePpairs propRotate padRight1compare1compare2