h&]T      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Copyright (c) 1998 Chris Okasaki1BSD3; see COPYRIGHT file for terms and conditionsrobdockins AT fastmail DOT fmstableGHC, Hugs (MPTC and FD) Safe-Inferred + EdisonAPIA pure MonadFail. EdisonAPIThis class represents a quantity that can be measured. It is calculated by an associative function with a unit (hence the Monoid superclass, and by a function which gives the measurement for an individual item. Some datastructures are able to speed up the calculation of a measure by caching intermediate values of the computation. EdisonAPIThis class represents hashable objects where the hash is reversible. #forall x :: a. unhash (hash x) == x Note that: hash (unhash i) == i"does not necessarily hold because % is not necessarily defined for all i, only for all i in the range of hash. EdisonAPIThis class represents hashable objects where the hash function is unique (injective). There are no new methods, just a stronger invariant: 0forall x,y :: a. (x == y) iff (hash x == hash y) EdisonAPIThis class represents hashable objects. If obeys the following invariant: 4forall x,y :: a. (x == y) implies (hash x == hash y)%Copyright (c) 1998-1999 Chris Okasaki0MIT; see COPYRIGHT file for terms and conditionsrobdockins AT fastmail DOT fmstableGHC, Hugs (MPTC and FD) Safe-Inferred{  EdisonAPIThe   class defines an interface for datatypes which implement sequences. A description for each function is given below.  EdisonAPI1Add a new element to the front/left of a sequence 'lcons x = Axioms: $lcons x xs = append (singleton x) xsThis function is always  unambiguous.Default running time: O( 1 ) EdisonAPI1Add a new element to the right/rear of a sequence 'rcons x = Axioms: $rcons x xs = append xs (singleton x)This function is always  unambiguous.Default running time: O( n ) EdisonAPIConvert a list into a sequence &fromList [x0,...,xn-1] = Axioms: "fromList xs = foldr lcons empty xsThis function is always  unambiguous.Default running time: O( n ) EdisonAPICreate a sequence containing n( copies of the given element. Return V if n<0. copy n x = Axioms: -n > 0 ==> copy n x = cons x (copy (n-1) x) n <= 0 ==> copy n x = emptyThis function is always  unambiguous.Default running time: O( n ) EdisonAPISeparate a sequence into its first (leftmost) element and the remaining sequence. Calls  if the sequence is empty.Axioms: lview empty = fail "lview (lcons x xs) = return (x,xs)This function is always  unambiguous.Default running time: O( 1 ) EdisonAPIReturn the first element of a sequence. Signals an error if the sequence is empty.Axioms: lhead empty = undefined lhead (lcons x xs) = xThis function is always  unambiguous.Default running time: O( 1 ) EdisonAPI3Returns the first element of a sequence. Calls  if the sequence is empty.Axioms: lheadM empty = fail lheadM (lcons x xs) = return xThis function is always  unambiguous.Default running time: O( 1 ) EdisonAPIDelete the first element of the sequence. Signals error if sequence is empty.Axioms: ltail empty = undefined ltail (lcons x xs) = xsThis function is always  unambiguous.Default running time: O( 1 ) EdisonAPI3Delete the first element of the sequence. Calls  if the sequence is empty.Axioms: ltailM empty = fail ltailM (lcons x xs) = return xsThis function is always  unambiguous.Default running time: O( 1 ) EdisonAPISeparate a sequence into its last (rightmost) element and the remaining sequence. Calls  if the sequence is empty.Axioms: rview empty = fail "rview (rcons x xs) = return (x,xs)This function is always  unambiguous.Default running time: O( n ) EdisonAPIReturn the last (rightmost) element of the sequence. Signals error if sequence is empty.Axioms: rhead empty = undefined rhead (rcons x xs) = xThis function is always  unambiguous.Default running time: O( n ) EdisonAPI4Returns the last element of the sequence. Calls  if the sequence is empty.Axioms: rheadM empty = fail rheadM (rcons x xs) = return xThis function is always  unambiguous.Default running time: O( n ) EdisonAPIDelete the last (rightmost) element of the sequence. Signals an error if the sequence is empty.Axioms: rtail empty = undefined rtail (rcons x xs) = xsThis function is always  unambiguous.Default running time: O( n ) EdisonAPI>Delete the last (rightmost) element of the sequence. Calls  of the sequence is emptyAxioms: rtailM empty = fail rtailM (rcons x xs) = return xsThis function is always  unambiguous.Default running time: O( n ) EdisonAPIReturns  if the sequence is empty and  otherwise. null = (n==0)Axioms: null xs = (size xs == 0)This function is always  unambiguous.Default running time: O( 1 ) EdisonAPI!Returns the length of a sequence. size = nAxioms: size empty = 0 size (lcons x xs) = 1 + size xsThis function is always  unambiguous.Default running time: O( n ) EdisonAPIConvert a sequence to a list. $toList = [x0,...,xn-1]Axioms: toList empty = [] #toList (lcons x xs) = x : toList xsThis function is always  unambiguous.Default running time: O( n ) EdisonAPI7Flatten a sequence of sequences into a simple sequence. #concat xss = foldr append empty xssAxioms: #concat xss = foldr append empty xssThis function is always  unambiguous.Default running time:  O( n + m ) where n) is the length of the input sequence and m& is length of the output sequence. EdisonAPIReverse the order of a sequence %reverse = Axioms: reverse empty = empty +reverse (lcons x xs) = rcons x (reverse xs)This function is always  unambiguous.Default running time: O( n )  EdisonAPI6Reverse a sequence onto the front of another sequence. reverseOnto = Axioms: *reverseOnto xs ys = append (reverse xs) ysThis function is always  unambiguous.Default running time: O( n1 )! EdisonAPICombine all the elements of a sequence into a single value, given a combining function and an initial value. The order in which the elements are applied to the combining function is unspecified. fold3 is one of the few ambiguous sequence functions.Axioms: fold f c empty = c 4f is fold-commutative ==> fold f = foldr f = foldl ffold f is  unambiguous iff f is fold-commutative.Default running type:  O( t * n ) where t is the running tome of f." EdisonAPIA strict variant of !. fold'3 is one of the few ambiguous sequence functions.Axioms: 6forall a. f a _|_ = _|_ ==> fold f x xs = fold' f x xsfold f is  unambiguous iff f is fold-commutative.Default running type:  O( t * n ) where t is the running tome of f.# EdisonAPICombine all the elements of a non-empty sequence into a single value, given a combining function. Signals an error if the sequence is empty.Axioms: 7f is fold-commutative ==> fold1 f = foldr1 f = foldl1 ffold1 f is  unambiguous iff f is fold-commutative.Default running type:  O( t * n ) where t is the running tome of f.$ EdisonAPIA strict variant of #.Axioms: 4forall a. f a _|_ = _|_ ==> fold1' f xs = fold1 f xsfold1' f is  unambiguous iff f is fold-commutative.Default running time:  O( t * n ) where t is the running time of f% EdisonAPICombine all the elements of a sequence into a single value, given a combining function and an initial value. The function is applied with right nesting. ;foldr (%) c = x0 % (x1 % ( ... % (xn-1 % c)))Axioms: foldr f c empty = c +foldr f c (lcons x xs) = f x (foldr f c xs)This function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of f& EdisonAPIStrict variant of %. Axioms: 8forall a. f a _|_ = _|_ ==> foldr f x xs = foldr' f x xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of f' EdisonAPICombine all the elements of a sequence into a single value, given a combining function and an initial value. The function is applied with left nesting. ;foldl (%) c = (((c % x0) % x1) % ... ) % xn-1Axioms: foldl f c empty = c +foldl f c (lcons x xs) = foldl f (f c x) xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of f( EdisonAPIStrict variant of '.Axioms:8forall a. f _|_ a = _|_ ==> foldl f z xs = foldl' f z xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of f) EdisonAPICombine all the elements of a non-empty sequence into a single value, given a combining function. The function is applied with right nesting. Signals an error if the sequence is empty. foldr1 (+) | n==0 = error "ModuleName.foldr1: empty sequence" | n>0 = x0 + (x1 + ... + xn-1)Axioms: foldr1 f empty = undefined $foldr1 f (rcons x xs) = foldr f x xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of f* EdisonAPIStrict variant of ).Axioms:6forall a. f a _|_ = _|_ ==> foldr1 f xs = foldr1' f xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of f+ EdisonAPICombine all the elements of a non-empty sequence into a single value, given a combining function. The function is applied with left nesting. Signals an error if the sequence is empty. foldl1 (+) | n==0 = error "ModuleName.foldl1: empty sequence" | n>0 = (x0 + x1) + ... + xn-1Axioms: foldl1 f empty = undefined $foldl1 f (lcons x xs) = foldl f x xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of f, EdisonAPIStrict variant of +.Axioms:6forall a. f _|_ a = _|_ ==> foldl1 f xs = foldl1' f xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of f- EdisonAPISee 1 for additional notes. &reducer f x xs = reduce1 f (cons x xs)Axioms:reducer f c xs = foldr f c xs for associative f reducer f is unambiguous iff f is an associative function.Default running time:  O( t * n ) where t is the running time of f. EdisonAPIStrict variant of -.See 1 for additional notes.Axioms: forall a. f a _|_ = _|_ && forall a. f _|_ a = _|_ ==> reducer f x xs = reducer' f x xs reducer' f is unambiguous iff f is an associative function.Default running time:  O( t * n ) where t is the running time of f/ EdisonAPISee 1 for additional notes. 'reducel f x xs = reduce1 f (rcons x xs)Axioms:reducel f c xs = foldl f c xs for associative f reducel f is unambiguous iff f is an associative function.Default running time:  O( t * n ) where t is the running time of f0 EdisonAPIStrict variant of /.See 1 for additional notes.Axioms: forall a. f a _|_ = _|_ && forall a. f _|_ a = _|_ ==> reducel f x xs = reducel' f x xs reducel' f is unambiguous iff f is an associative function.Default running time:  O( t * n ) where t is the running time of f1 EdisonAPIA reduce is similar to a fold, but combines elements in a balanced fashion. The combining function should usually be associative. If the combining function is associative, the various reduce functions yield the same results as the corresponding folds.;What is meant by "in a balanced fashion"? We mean that reduce1 (%) - equals some complete parenthesization of x0 % x1 % ... % xn-12 such that the nesting depth of parentheses is  O( log n ). The precise shape of this parenthesization is unspecified. reduce1 f = x reduce1 f = f (reduce1 f ) (reduce1 f ) for some i such that  0 <= i && i < n-1 =Although the exact value of i is unspecified it tends toward n/2" so that the depth of calls to f is at most logarithmic. Note that reduce* are some of the only sequence operations for which different implementations are permitted to yield different answers. Also note that a single implementation may choose different parenthisizations for different sequences, even if they are the same length. This will typically happen when the sequences were constructed differently.The canonical applications of the reduce functions are algorithms like merge sort where: 5mergesort xs = reducer merge empty (map singleton xs)Axioms: reduce1 f empty = undefined(reduce1 f xs = foldr1 f xs = foldl1 f xs for associative f reduce1 f is unambiguous iff f is an associative function.Default running time:  O( t * n ) where t is the running time of f2 EdisonAPIStrict variant of 1.Axioms: forall a. f a _|_ = _|_ && forall a. f _|_ a = _|_ ==> reduce1 f xs = reduce1' f xs reduce1' f is unambiguous iff f is an associative function.Default running time:  O( t * n ) where t is the running time of f3 EdisonAPIExtract a prefix of length i from the sequence. Return V if i( is negative, or the entire sequence if i is too large. take i xs = fst (splitAt i xs)Axioms: "i < 0 ==> take i xs = empty i > size xs ==> take i xs = xs +size xs == i ==> take i (append xs ys) = xsThis function is always  unambiguous.Default running time: O( i )4 EdisonAPIDelete a prefix of length i4 from a sequence. Return the entire sequence if i is negative, or V if i is too large. drop i xs = snd (splitAt i xs)Axioms: i < 0 ==> drop i xs = xs "i > size xs ==> drop i xs = empty +size xs == i ==> drop i (append xs ys) = ysThis function is always  unambiguous.Default running time: O( i )5 EdisonAPI)Split a sequence into a prefix of length i and the remaining sequence. Behaves the same as the corresponding calls to 3 and 4 if i is negative or too large. splitAt i xs | i < 0 = (<> , ) | i < n = (, ) | i >= n = (, <> )Axioms: $splitAt i xs = (take i xs,drop i xs)This function is always  unambiguous.Default running time: O( i )6 EdisonAPIExtract a subsequence from a sequence. The integer arguments are "start index" and "length" NOT "start index" and "end index". Behaves the same as the corresponding calls to 3 and 4; if the start index or length are negative or too large. &subseq i len xs = take len (drop i xs)Axioms: &subseq i len xs = take len (drop i xs)This function is always  unambiguous.Default running time:  O( i + len )7 EdisonAPIExtract the elements of a sequence that satisfy the given predicate, retaining the relative ordering of elements from the original sequence. filter p xs = foldr pcons empty xs where pcons x xs = if p x then cons x xs else xsAxioms: filter p empty = empty filter p (lcons x xs) = if p x then lcons x (filter p xs) else filter p xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of p8 EdisonAPISeparate the elements of a sequence into those that satisfy the given predicate and those that do not, retaining the relative ordering of elements from the original sequence. 3partition p xs = (filter p xs, filter (not . p) xs)Axioms: 3partition p xs = (filter p xs, filter (not . p) xs)This function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of p9 EdisonAPIExtract the maximal prefix of elements satisfying the given predicate. &takeWhile p xs = fst (splitWhile p xs)Axioms: takeWhile p empty = empty takeWhile p (lcons x xs) = if p x then lcons x (takeWhile p xs) else emptyThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of p: EdisonAPIDelete the maximal prefix of elements satisfying the given predicate. &dropWhile p xs = snd (splitWhile p xs)Axioms: dropWhile p empty = empty dropWhile p (lcons x xs) = if p x then dropWhile p xs else lcons x xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of p; EdisonAPISplit a sequence into the maximal prefix of elements satisfying the given predicate, and the remaining sequence. splitWhile p = (, ) where i = min j such that p xj (or n if no such j)Axioms: 1splitWhile p xs = (takeWhile p xs,dropWhile p xs)This function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of p< EdisonAPITest whether an index is valid for the given sequence. All indexes are 0 based. ,inBounds i = (0 <= i && i < n)Axioms: 'inBounds i xs = (0 <= i && i < size xs)This function is always  unambiguous.Default running time: O( i )= EdisonAPIReturn the element at the given index. All indexes are 0 based. Signals error if the index out of bounds. lookup i xs@ | inBounds i xs = xi | otherwise = error "ModuleName.lookup: index out of bounds"Axioms: 0not (inBounds i xs) ==> lookup i xs = undefined 6size xs == i ==> lookup i (append xs (lcons x ys)) = xThis function is always  unambiguous.Default running time: O( i )> EdisonAPIReturn the element at the given index. All indexes are 0 based. Calls  if the index is out of bounds. lookupM i xs@ | inBounds i xs = Just xi | otherwise = NothingAxioms: +not (inBounds i xs) ==> lookupM i xs = fail >size xs == i ==> lookupM i (append xs (lcons x ys)) = return xThis function is always  unambiguous.Default running time: O( i )? EdisonAPIReturn the element at the given index, or the default argument if the index is out of bounds. All indexes are 0 based. lookupWithDefault d i xs@ | inBounds i xs = xi | otherwise = dAxioms: 4not (inBounds i xs) ==> lookupWithDefault d i xs = d size xs == i ==> lookupWithDefault d i (append xs (lcons x ys)) = xThis function is always  unambiguous.Default running time: O( i )@ EdisonAPIReplace the element at the given index, or return the original sequence if the index is out of bounds. All indexes are 0 based. update i y xs@ | inBounds i xs = | otherwise = xsAxioms: *not (inBounds i xs) ==> update i y xs = xs size xs == i ==> update i y (append xs (lcons x ys)) = append xs (lcons y ys)This function is always  unambiguous.Default running time: O( i )A EdisonAPIApply a function to the element at the given index, or return the original sequence if the index is out of bounds. All indexes are 0 based. adjust f i xs@ | inBounds i xs = | otherwise = xsAxioms: *not (inBounds i xs) ==> adjust f i xs = xs size xs == i ==> adjust f i (append xs (lcons x ys)) = append xs (cons (f x) ys)This function is always  unambiguous.Default running time:  O( i + t ) where t is the running time of fB EdisonAPILike S, but include the index with each element. All indexes are 0 based. 8mapWithIndex f = Axioms: mapWithIndex f empty = empty mapWithIndex f (rcons x xs) = rcons (f (size xs) x) (mapWithIndex f xs)This function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of fC EdisonAPILike %, but include the index with each element. All indexes are 0 based. foldrWithIndex f c = f 0 x0 (f 1 x1 (... (f (n-1) xn-1 c)))Axioms: foldrWithIndex f c empty = c foldrWithIndex f c (rcons x xs) = foldrWithIndex f (f (size xs) x c) xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of fD EdisonAPIStrict variant of C.Axioms: forall i a. f i a _|_ = _|_ ==> foldrWithIndex f x xs = foldrWithIndex' f x xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of fE EdisonAPILike ', but include the index with each element. All indexes are 0 based. foldlWithIndex f c = f (...(f (f c 0 x0) 1 x1)...) (n-1) xn-1)Axioms: foldlWithIndex f c empty = c foldlWithIndex f c (rcons x xs) = f (foldlWithIndex f c xs) (size xs) xThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of fF EdisonAPIStrict variant of E.Axioms: forall i a. f _|_ i a = _|_ ==> foldlWithIndex f x xs = foldlWithIndex' f x xsThis function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of fG EdisonAPICombine two sequences into a sequence of pairs. If the sequences are different lengths, the excess elements of the longer sequence is discarded. zip = <(x0,y0),...,(xj-1,yj-1)> where j = min {n,m}Axioms: zip xs ys = zipWith (,) xs ysThis function is always  unambiguous.Default running time: O( min( n1, n2 ) )H EdisonAPILike G,, but combines three sequences into triples. zip3 = <(x0,y0,z0),...,(xj-1,yj-1,zj-1)> where j = min {n,m,k}Axioms: &zip3 xs ys zs = zipWith3 (,,) xs ys zsThis function is always  unambiguous.Default running time: O( min( n1, n2, n3 ) )I EdisonAPICombine two sequences into a single sequence by mapping a combining function across corresponding elements. If the sequences are of different lengths, the excess elements of the longer sequence are discarded. -zipWith f xs ys = map (uncurry f) (zip xs ys)Axioms: zipWith f (lcons x xs) (lcons y ys) = lcons (f x y) (zipWith f xs ys) .(null xs || null ys) ==> zipWith xs ys = emptyThis function is always  unambiguous.Default running time: O( t * min( n1, n2 ) ) where t is the running time of fJ EdisonAPILike I7 but for a three-place function and three sequences. 5zipWith3 f xs ys zs = map (uncurry f) (zip3 xs ys zs)Axioms: zipWith3 (lcons x xs) (lcons y ys) (lcons z zs) = lcons (f x y z) (zipWith3 f xs ys zs)This function is always  unambiguous.Default running time: O( t * min( n1, n2, n3 ) ) where t is the running time of fK EdisonAPI7Transpose a sequence of pairs into a pair of sequences. #unzip xs = (map fst xs, map snd xs)Axioms: !unzip xys = unzipWith fst snd xysThis function is always  unambiguous.Default running time: O( n )L EdisonAPI:Transpose a sequence of triples into a triple of sequences unzip3 xs = (map fst3 xs, map snd3 xs, map thd3 xs) where fst3 (x,y,z) = x snd3 (x,y,z) = y thd3 (x,y,z) = zAxioms: ,unzip3 xyzs = unzipWith3 fst3 snd3 thd3 xyzsThis function is always  unambiguous.Default running time: O( n )M EdisonAPIMap two functions across every element of a sequence, yielding a pair of sequences 'unzipWith f g xs = (map f xs, map g xs)Axioms: 'unzipWith f g xs = (map f xs, map g xs)This function is always  unambiguous.Default running time:  O( t * n ) where t% is the maximum running time of f and gN EdisonAPIMap three functions across every element of a sequence, yielding a triple of sequences. 4unzipWith3 f g h xs = (map f xs, map g xs, map h xs)Axioms: 2unzipWith3 f g h xs = (map f xs,map g xs,map h xs)This function is always  unambiguous.Default running time:  O( t * n ) where t% is the maximum running time of f, g, and hO EdisonAPISemanticly, this function is a partial identity function. If the datastructure is infinite in size or contains exceptions or non-termination in the structure itself, then strict will result in bottom. Operationally, this function walks the datastructure forcing any closures. Elements contained in the sequence are not forced.Axioms:strict xs = xs OR strict xs = _|_This function is always  unambiguous.Default running time: O( n )P EdisonAPI Similar to O, this function walks the datastructure forcing closures. However,  strictWith will additionally apply the given function to the sequence elements, force the result using seq, and then ignore it. This function can be used to perform various levels of forcing on the sequence elements. In particular: strictWith id xswill force the spine of the datastructure and reduce each element to WHNF.Axioms:forall  f :: a -> b, strictWith f xs = xs OR strictWith f xs = _|_This function is always  unambiguous.Default running time: unbounded (forcing element closures can take arbitrarily long)Q EdisonAPI.A method to facilitate unit testing. Returns  if the structural invariants of the implementation hold for the given sequence. If this function returns ,, it represents a bug in the implementation.R EdisonAPI&The name of the module implementing s.S EdisonAPIReturn the result of applying a function to every element of a sequence. Identical to fmap from Functor. 'map f = Axioms: map f empty = empty +map f (lcons x xs) = lcons (f x) (map f xs)This function is always  unambiguous.Default running time:  O( t * n ) where t is the running time of fT EdisonAPI+Create a singleton sequence. Identical to return from Monad. singleton x = Axioms: +singleton x = lcons x empty = rcons x emptyThis function is always  unambiguous.Default running time: O( 1 )U EdisonAPIApply a sequence-producing function to every element of a sequence and flatten the result. U is the bind (>>=) operation of from Monad, with the arguments in the reverse order. "concatMap f xs = concat (map f xs)Axioms: "concatMap f xs = concat (map f xs)This function is always  unambiguous.Default running time: O( t * n + m ) where n& is the length of the input sequence, m0 is the length of the output sequence, and t is the running time of fV EdisonAPI"The empty sequence. Identical to mzero from  MonadPlus.  empty = <>This function is always  unambiguous.Default running time: O( 1 )W EdisonAPIAppend two sequence, with the first argument on the left and the second argument on the right. Identical to mplus from  MonadPlus. >append = Axioms:  append xs ys = foldr lcons ys xsThis function is always  unambiguous.Default running time: O( n1 ) I7'%G4:(+,)=539KLHJA8!&  "#$*-./012<>?@BCDEF6;MNOPQRSTUVWSTUVW I7'%G4:(+,)=539KLHJA8!&  "#$*-./012<>?@BCDEF6;MNOPQR Copyright (c) 1998 Chris Okasaki0MIT; see COPYRIGHT file for terms and conditionsrobdockins AT fastmail DOT fmstableGHC, Hugs (MPTC and FD) Safe-Inferred}#XYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~XZ[\]^_a`cbdfehgijklmnopqrstuvxwyz{|}~Y Copyright (c) 1998 Chris Okasaki0MIT; see COPYRIGHT file for terms and conditionsrobdockins AT fastmail DOT fmstableGHC, Hugs (MPTC and FD) Safe-Inferred EdisonAPICollections with observable elements where the set property is maintained and where additionally, there is an ordering relation on the elements. This class introduces no new methods, and is simply an abbreviation for the context: (OrdColl c a,Set c a) EdisonAPICollections with observable elements where the set property is maintained; that is, a set contains at most one element of the equivalence class formed by the  instance on the elements.:WARNING: Each of the following "With" functions is unsafe. The passed in combining functions are used to choose which element is kept in the case of duplicates. They are required to satisfy the precondition that, given two equal elements, they return a third element equal to the other two. Usually, the combining function just returns its first or second argument, but it can combine elements in non-trivial ways.The combining function should usually be associative. Where the function involves a sequence of elements, the elements will be combined from left-to-right, but with an unspecified associativity.For example, if  x == y == z , then fromSeqWith (+) [x,y,z] equals either single (x + (y + z)) or single ((x + y) + z) EdisonAPISame as 7 but with a combining function to resolve duplicates. This function is  unambiguous under the "with" precondition if the combining function is associative. Otherwise it is  ambiguous. EdisonAPISame as 5 but with a combining function to resolve duplicates.This function is  unambiguous under the "with" precondition. EdisonAPISame as 5 but with a combining function to resolve duplicates.This function is  unambiguous under the "with" precondition if the combining function is associative. Otherwise it is  ambiguous. EdisonAPILeft biased union.Axioms: unionl = unionWith (\x y -> x)This function is always  unambiguous. EdisonAPIRight biased union.Axioms: unionr = unionWith (\x y -> y)This function is always  unambiguous. EdisonAPISame as :, but with a combining function to resolve duplicates. This function is  unambiguous under the "with" precondition. EdisonAPISame as 6, but with a combining function to resolve duplicates.This function is  unambiguous under the "with" precondition if the combining function is associative. Otherwise it is  ambiguous. EdisonAPISame as 6, but with a combining function to resolve duplicates.This function is  unambiguous under the "with" precondition. EdisonAPICollections with observable elements where the elements additionally have an ordering relation. See the module documentation for comments on observability. EdisonAPIReturn the minimum element in the collection, together with the collection without that element. If there are multiple copies of the minimum element, it is unspecified which is chosen. Note that , , and ' may make different choices. Calls  if the collection is empty.This function is  ambiguous at bag types, if more than one minimum element exists in the bag. Otherwise, it is  unambiguous. EdisonAPIReturn the minimum element in the collection. If there are multiple copies of the minimum element, it is unspecified which is chosen. Note that , , and  may make different choices. Signals an error if the collection is empty.This function is  ambiguous at bag types, if more than one minimum element exists in the bag. Otherwise, it is  unambiguous. EdisonAPIReturn the maximum element in the collection, together with the collection without that element. If there are multiple copies of the maximum element, it is unspecified which is chosen. Note that ,  and ' may make different choices. Calls  if the collection is empty.This function is  ambiguous at bag types, if more than one maximum element exists in the bag. Otherwise, it is  unambiguous. EdisonAPIReturn the maximum element in the collection. If there are multiple copies of the maximum element, it is unspecified which is chosen. Note that ,  and  may make different choices. Signals an error if the collection is empty.This function is  ambiguous at bag types, if more than one maximum element exists in the bag. Otherwise, it is  unambiguous. EdisonAPIFold across the elements in non-decreasing order with right associativity. (For sets, this will always be increasing order)This function is  unambiguous if the combining function is fold-commutative, at all set types, and at bag types where no two equivalent elements exist in the bag. Otherwise it is  ambiguous. EdisonAPIA strict variant of .This function is  unambiguous if the combining function is fold-commutative, at all set types, and at bag types where no two equivalent elements exist in the bag. Otherwise it is  ambiguous. EdisonAPIFold across the elements in non-decreasing order with left associativity. (For sets, this will always be increasing order)This function is  unambiguous if the combining function is fold-commutative, at all set types, and at bag types where no two equivalent elements exist in the bag. Otherwise it is  ambiguous. EdisonAPIA strict variant of .This function is  unambiguous if the combining function is fold-commutative, at all set types, and at bag types where no two equivalent elements exist in the bag. Otherwise it is  ambiguous. EdisonAPIFold across the elements in non-decreasing order with right associativity, or signal an error if the collection is empty. (For sets, this will always be increasing order)This function is  unambiguous if the combining function is fold-commutative, at all set types, and at bag types where no two equivalent elements exist in the bag. Otherwise it is  ambiguous. EdisonAPIA strict variant of .This function is  unambiguous if the combining function is fold-commutative, at all set types, and at bag types where no two equivalent elements exist in the bag. Otherwise it is  ambiguous. EdisonAPIFold across the elements in non-decreasing order with left associativity, or signal an error if the collection is empty. (For sets, this will always be increasing order)This function is  unambiguous if the combining function is fold-commutative, at all set types, and at bag types where no two equivalent elements exist in the bag. Otherwise it is  ambiguous. EdisonAPIA strict variant of .This function is  unambiguous if the combining function is fold-commutative, at all set types, and at bag types where no two equivalent elements exist in the bag. Otherwise it is  ambiguous. EdisonAPIList the elements in non-decreasing order. (For sets, this will always be increasing order)At set types, this function is  unambiguous. At bag types, it is  unambiguous if no two equivalent elements exist in the bag; otherwise it is  ambiguous. EdisonAPIMap a monotonic function across all elements of a collection. The function is required to satisfy the following precondition: forall x y. x < y ==> f x < f yThis function is  unambiguous, under the precondition. EdisonAPICollections with observable elements. See the module documentation for comments on observability. EdisonAPI= any existing elements in the collection. For sets, the precondition is strengthened to >.This function is  unambiguous , under the above preconditions. EdisonAPIConvert a sequence in non-decreasing order into a collection. For sets, the sequence must be in increasing order.This function is  unambiguous , under the above preconditions. EdisonAPIUnion two collections where every element in the first collection is <= every element in the second collection. For sets, this precondition is strengthened to <.This function is  unambiguous , under the above preconditions. EdisonAPI'Extract the sub-collection of elements < the given element.Axioms: filterLT x xs = filter (< x) xsThis function is always  unambiguous. EdisonAPI'Extract the sub-collection of elements <= the given element.Axioms:  filterLE x xs = filter (<= x) xsThis function is always  unambiguous. EdisonAPI'Extract the sub-collection of elements > the given element.Axioms: filterGT x xs = filter (> x) xsThis function is always  unambiguous. EdisonAPI'Extract the sub-collection of elements >= the given element.Axioms:  filterGE x xs = filter (>= x) xsThis function is always  unambiguous. EdisonAPI'Split a collection into those elements < a given element and those >=.Axioms: $partitionLT_GE xs = partition (<) xsThis function is always  unambiguous. EdisonAPI'Split a collection into those elements <= a given element and those >.Axioms: %partitionLE_GT xs = partition (<=) xsThis function is always  unambiguous. EdisonAPI'Split a collection into those elements < a given element and those >9. All elements equal to the given element are discarded.Axioms: 3partitionLT_GT x xs = (filterLT x xs,filterGT x xs)This function is always  unambiguous. EdisonAPIThis is the root class of the collection hierarchy. However, it is perfectly adequate for many applications that use sets or bags. EdisonAPIcreate a singleton collectionThis function is always  unambiguous. EdisonAPIConvert a sequence to a collection. For sets, it is unspecified which element is kept in case of duplicates.This function is  ambiguous at set types if more than one equivalent item is in the sequence. Otherwise it is  unambiguous. EdisonAPIMerge a sequence of collections. For sets, it is unspecified which element is kept in the case of duplicates.This function is  ambiguous at set types if the sets in the sequence are not mutually disjoint. Otherwise it is  unambiguous. EdisonAPIInsert an element into a collection. For sets, if an equal element is already in the set, the newly inserted element is kept, and the old element is discarded.This function is always  unambiguous. EdisonAPIInsert a sequence of elements into a collection. For sets, the behavior with regard to multiple equal elements is unspecified.This function is  ambiguous at set types if the sequence contains more than one equivalent item or an item which is already in the set. Otherwise it is  unambiguous. EdisonAPIDelete a single occurrence of the given element from a collection. For bags, it is unspecified which element will be deleted.This function is  ambiguous at bag types if more than one item exists in the bag equivalent to the given item. Otherwise it is  unambiguous. EdisonAPIDelete all occurrences of an element from a collection. For sets this operation is identical to .This function is always  unambiguous. EdisonAPIDelete a single occurrence of each of the given elements from a collection. For bags, there may be multiple occurrences of a given element in the collection, in which case it is unspecified which is deleted.This function is  ambiguous at bag types if more than one item exists in the bag equivalent to any item in the list and the number of equivalent occurrences of that item in the sequence is less than the number of occurrences in the bag. Otherwise it is  unambiguous. EdisonAPI%Test whether the collection is empty.Axioms: null xs = (size xs == 0)This function is always  unambiguous. EdisonAPI0Return the number of elements in the collection.This function is always  unambiguous. EdisonAPI4Test whether the given element is in the collection.Axioms: member x xs = (count x xs > 0)This function is always  unambiguous. EdisonAPICount how many copies of the given element are in the collection. For sets, this will always return 0 or 1.This function is always  unambiguous. EdisonAPISemanticly, this function is a partial identity function. If the datastructure is infinite in size or contains exceptions or non-termination in the structure itself, then strict will result in bottom. Operationally, this function walks the datastructure forcing any closures. In many collections, the collction "shape" depends on the value of the elements; in such cases, the values of the elements will be forced to the extent necessary to force the structure of the collection, but no further.This function is always  unambiguous. EdisonAPI.A method to facilitate unit testing. Returns  if the structural invariants of the implementation hold for the given collection. If this function returns , it represents a bug; generally, either the implementation itself is flawed, or an unsafe operation has been used while violating the preconditions. EdisonAPI$The name of the module implementing c EdisonAPI%The empty collection. Equivalent to mempty from the Monoid instance.This function is always  unambiguous. EdisonAPIMerge two collections. For sets, it is unspecified which element is kept in the case of duplicates. Equivalent to mappend from the Monoid instance.This function is  ambiguous? at set types if the sets are not disjoint. Otherwise it is  unambiguous. EdisonAPIdefault element EdisonAPIelement to lookup EdisonAPI collection Copyright (c) 1998 Chris Okasaki0MIT; see COPYRIGHT file for terms and conditionsrobdockins AT fastmail DOT fmstableGHC, Hugs (MPTC and FD) Safe-Inferred҅ EdisonAPIApply a function across all the elements in a collection and transform the collection type. EdisonAPIMap a partial function across all elements of a collection and transform the collection type. EdisonAPIMap a monotonic function across all the elements of a collection and transform the collection type. The function is required to satisfy the following precondition: forall x y. x < y ==> f x < f y EdisonAPIMap a collection-producing function across all elements of a collection and collect the results together using . Copyright (c) 1998 Chris Okasaki0MIT; see COPYRIGHT file for terms and conditionsrobdockins AT fastmail DOT fmstableGHC, Hugs (MPTC and FD) Safe-InferredN/ EdisonAPIFinite maps with observable keys where the keys additionally have an ordering relation. This class introduces no new methods. EdisonAPI!Finite maps with observable keys. EdisonAPISame as , but with a combining function to resolve duplicates. The combining function additionally takes the key. Which key is kept and passed into the combining function is unspecified.This function is  unambiguous provided that the Eq9 instance on keys corresponds to indistinguishability. EdisonAPISame as , but with a combining function to resolve duplicates. The combining function additionally takes the key. Which key is kept and passed into the combining function is unspecified.This function is  unambiguous provided that the Eq9 instance on keys corresponds to indistinguishability. EdisonAPISame as , except that the combining function additionally takes the key value for each binding. Which key is kept and passed into the combining function is unspecified.This function is  unambiguous provided the Eq9 instance on keys corresponds to indistinguishability. EdisonAPIAn associative collection with observable keys where the keys additionally have an ordering relation. EdisonAPIDelete the binding with the minimum key from an associative collection and return the key, the element and the remaining associative collection. Calls  if the associative collection is empty. Which binding is chosen if there are multiple minimum keys is unspecified.This function is  ambiguous at finite relation types if more than one minimum key exists in the relation. Furthermore, it is  ambiguous7 with respect to the actual key observed unless the Eq8 instance on keys corresponds to indistinguisability. EdisonAPIFind the binding with the minimum key in an associative collection and return the key and the element. Signals an error if the associative collection is empty. Which binding is chosen if there are multiple minimum keys is unspecified.This function is  ambiguous at finite relation types if more than one minimum key exists in the relation. Furthermore, it is  ambiguous7 with respect to the actual key observed unless the Eq8 instance on keys corresponds to indistinguisability. EdisonAPIDelete the binding with the maximum key from an associative collection and return the key, the element and the remaining associative collection. Calls  if the associative collection is empty. Which binding is chosen if there are multiple maximum keys is unspecified.This function is  ambiguous at finite relation types if more than one maximum key exists in the relation. Furthermore, it is  ambiguous7 with respect to the actual key observed unless the Eq8 instance on keys corresponds to indistinguisability. EdisonAPIFind the binding with the maximum key in an associative collection and return the key and the element. Signals an error if the associative collection is empty. Which binding is chosen if there are multiple maximum keys is unspecified.This function is  ambiguous at finite relation types if more than one maximum key exists in the relation. Furthermore, it is  ambiguous7 with respect to the actual key observed unless the Eq8 instance on keys corresponds to indistinguisability. EdisonAPIFold over all bindings in an associative collection in non-decreasing order by key with right associativity, given a combining function and an initial value. For finite maps, the order is increasing.foldrWithKey f is  ambiguous at finite relation types if the relation contains more than one equivalent key and f# is not fold-commutative OR if the Eq instance on keys does not correspond to indistingusihability. EdisonAPIA strict variant of .foldrWithKey' f is  ambiguous at finite relation types if the relation contains more than one equivalent key and f# is not fold-commutative OR if the Eq instance on keys does not correspond to indistingusihability. Otherwise it is  unambiguous. EdisonAPIFold over all bindings in an associative collection in non-decreasing order by key with left associativity, given a combining function and an initial value. For finite maps, the order is increasing.foldlWithKey f is  ambiguous at finite relation types if the relation contains more than one equivalent key and f# is not fold-commutative OR if the Eq instance on keys does not correspond to indistingusihability. Otherwise it is  unambiguous. EdisonAPIA strict variant of .foldlWithKey' f is  ambiguous at finite relation types if the relation contains more than one equivalent key and f# is not fold-commutative OR if the Eq instance on keys does not correspond to indistinguishability. Otherwise it is  unambiguous. EdisonAPIExtract the bindings of an associative collection into a sequence, where the bindings are in non-decreasing order by key. For finite maps, this is increasing order.This function is  ambiguous at finite relation types if the relation contains more than one equivalent key, or if the Eq instance on keys does not correspond to indistinguishability. EdisonAPI6Associative collections where the keys are observable. EdisonAPIExtract the bindings of an associative collection into a sequence. The bindings are emitted in an unspecified order.This function is  ambiguous with respect to the sequence order iff the associative collection contains more than one binding. Furthermore, it is  ambiguous8 with respect to the actual key returned, unless the Eq8 instance on keys corresponds to indistinguisability. EdisonAPIExtract the keys of an associative collection into a sequence. The keys are emitted in an unspecified order. For finite relations, keys which appear multiple times in the relation will appear as many times in the extracted sequence.This function is  ambiguous with respect to the sequence order iff the associative collection contains more than one binding. Furthermore, it is  ambiguous8 with respect to the actual key returned, unless the Eq8 instance on keys corresponds to indistinguisability. EdisonAPIApply a function to every element in an associative collection. The mapped function additionally takes the value of the key.This function is  ambiguous9 with respect to the actual keys observed, unless the Eq8 instance on keys corresponds to indistinguisability. EdisonAPICombine all the elements in the associative collection, given a combining function and an initial value. The elements are processed in an unspecified order. The combining function additionally takes the value of the key. foldWithKey f is  unambiguous iff f is fold-commutative and the Eq5 instance on keys corresponds to indistinguisability. EdisonAPIA strict variant of .foldWithKey' f is  unambiguous iff f is fold-commutative and the Eq5 instance on keys corresponds to indistinguisability. EdisonAPIExtract all bindings from an associative collection which satisfy the given predicate.This function is  ambiguous9 with respect to the actual keys observed, unless the Eq8 instance on keys corresponds to indistinguisability. EdisonAPISplit an associative collection into two sub-collections containing those bindings which satisfy the given predicate and those which do not.This function is  ambiguous9 with respect to the actual keys observed, unless the Eq8 instance on keys corresponds to indistinguisability. EdisonAPIFinite maps where the keys additionally have an ordering relation. This class introduces no new methods. EdisonAPIAn associative collection where the keys form a set; that is, each key appears in the associative collection at most once. EdisonAPISame as 6, but with a combining function to resolve duplicates.This function is always  unambiguous. EdisonAPISame as , but with a combining function to resolve duplicates; the combining function takes the key in addition to the two elements.This function is always  unambiguous. EdisonAPISame as 6, but with a combining function to resolve duplicates.This function is  unambiguous. EdisonAPISame as , but with a combining function to resolve duplicates; the combining function takes the key in addition to the two elements. The key passed to the combining function is always the same as the given key.This function is  unambiguous. EdisonAPISame as 6, but with a combining function to resolve duplicates.This function is  unambiguous. EdisonAPISame as , but with a combining function to resolve duplicates; the combining function takes the key in addition to the two elements.This function is  unambiguous. EdisonAPILeft biased union.Axioms: unionl = unionwith (\x y -> x)This function is  unambiguous. EdisonAPIRight biased union.Axioms: unionr = unionWith (\x y -> y)This function is  unambiguous. EdisonAPISame as 6, but with a combining function to resolve duplicates.This function is  unambiguous. EdisonAPISame as 6, but with a combining function to resolve duplicates.This function is  unambiguous. EdisonAPICompute the intersection of two finite maps. The resulting finite map will contain bindings where the keys are the set intersection of the keys in the argument finite maps. The combining function computes the value of the element given the bound elements from the argument finite maps.This function is  unambiguous. EdisonAPIComputes the difference of two finite maps; that is, all bindings in the first finite map whose keys to not appear in the second.This function is always  unambiguous. EdisonAPITest whether the set of keys in the first finite map is a proper subset of the set of keys of the second; that is, every key present in the first finite map is also a member of the second finite map AND there exists some key in the second finite map which is not present in the first.This function is always  unambiguous. EdisonAPITest whether the set of keys in the first finite map is a subset of the set of keys of the second; that is, if every key present in the first finite map is also present in the second.This function is always  unambiguous. EdisonAPITest whether the first map is a submap of the second map given a comparison function on elements; that is, if every key present in the first map is also present in the second map and the comparison function returns true when applied two the bound elements.This function is always  unambiguous. EdisonAPITest whether the first map is a proper submap of the second map given a comparison function on elements; that is, if every key present in the first map is also present in the second map and the comparison function returns true when applied two the bound elements AND there exiss some key in the second finite map which is not present in the first.This function is always  unambiguous. EdisonAPITest whether the first map is the "same" map as the second map given a comparison function on elements; that is, if the first and second maps have the same set of keys and the comparison function returns true when applied to corresponding elements.This function is always  unambiguous. EdisonAPIAn associative collection where the keys additionally have an ordering relation. EdisonAPIRemove the binding with the minimum key, and return its element together with the remaining associative collection. Calls  if the associative collection is empty. Which binding is removed if there is more than one minimum is unspecified.This function is  ambiguous at finite relation types if the finite relation contains more than one minimum key. Otherwise it is  unambiguous. EdisonAPIFind the binding with the minimum key and return its element. Signals an error if the associative collection is empty. Which element is chosen if there is more than one minimum is unspecified.This function is  ambiguous at finite relation types if the finite relation contains more than one minimum key. Otherwise it is  unambiguous. EdisonAPIRemove the binding with the minimum key and return the remaining associative collection, or return empty if it is already empty.This function is  ambiguous at finite relation types if the finite relation contains more than one minimum key. Otherwise it is  unambiguous. EdisonAPIInsert a binding into an associative collection with the precondition that the given key is <= any existing keys already in the collection. For finite maps, this precondition is strengthened to <.This function is  unambiguous under the preconditions. EdisonAPIRemove the binding with the maximum key, and return its element together with the remaining associative collection. Calls  if the associative collection is empty. Which binding is removed if there is more than one maximum is unspecified.This function is  ambiguous at finite relation types if the finite relation contains more than one minimum key. Otherwise it is  unambiguous. EdisonAPIFind the binding with the maximum key and return its element. Signals an error if the associative collection is empty. Which element is chosen if there is more than one maximum is unspecified.This function is  ambiguous at finite relation types if the finite relation contains more than one minimum key. Otherwise it is  unambiguous. EdisonAPIRemove the binding with the maximum key and return the remaining associative collection, or return empty if it is already empty.This function is  ambiguous at finite relation types if the finite relation contains more than one minimum key. Otherwise it is  unambiguous. EdisonAPIInsert a binding into an associative collection with the precondition that the given key is >= any existing keys already in the collection. For finite maps, this precondition is strengthened to >.This function is  unambiguous under the precondition. EdisonAPIFold across the elements of an associative collection in non-decreasing order by key with right associativity. For finite maps, the order is increasing.foldr f is  unambiguous if f is fold-commutative, at finite map types, or at finite relation types if the relation contains no duplicate keys. Otherwise it is  ambiguous. EdisonAPIA strict variant of .foldr' f is  unambiguous if f is fold-commutative, at finite map types, or at finite relation types if the relation contains no duplicate keys. Otherwise it is  ambiguous. EdisonAPIFold across the elements of an associative collection in non-decreasing order by key with left associativity. For finite maps, the order is increasing.foldl f is  unambiguous if f is fold-commutative, at finite map types, or at finite relation types if the relation contains no duplicate keys. Otherwise it is  ambiguous. EdisonAPIA strict variant of .foldl' f is  unambiguous if f is fold-commutative, at finite map types, or at finite relation types if the relation contains no duplicate keys. Otherwise it is  ambiguous. EdisonAPIFold across the elements of an associative collection in non-decreasing order by key with right associativity. Signals an error if the associative collection is empty. For finite maps, the order is increasing.foldr1 f is  unambiguous if f is fold-commutative, at finite map types, or at finite relation types if the relation contains no duplicate keys. Otherwise it is  ambiguous. EdisonAPIA strict variant of . foldr1' f is  unambiguous if f is fold-commutative, at finite map types, or at finite relation types if the relation contains no duplicate keys. Otherwise it is  ambiguous. EdisonAPIFold across the elements of an associative collection in non-decreasing order by key with left associativity. Signals an error if the associative collection is empty. For finite maps, the order is increasing.foldl1 f is  unambiguous if f is fold-commutative, at finite map types, or at finite relation types if the relation contains no duplicate keys. Otherwise it is  ambiguous. EdisonAPIA strict variant of . foldl1' f is  unambiguous if f is fold-commutative, at finite map types, or at finite relation types if the relation contains no duplicate keys. Otherwise it is  ambiguous. EdisonAPIConvert a sequence of bindings into an associative collection with the precondition that the sequence is sorted into non-decreasing order by key. For finite maps, this precondition is strengthened to increasing order.This function is  unambiguous under the precondition. EdisonAPIMerge two associative collections with the precondition that every key in the first associative collection is <= every key in the second associative collection. For finite maps, this precondition is strengthened to <.This function is  unambiguous under the precondition. EdisonAPI$Extract all bindings whose keys are < the given key.This function is always  unambiguous. EdisonAPI$Extract all bindings whose keys are <= the given key.This function is always  unambiguous. EdisonAPI$Extract all bindings whose keys are > the given key.This function is always  unambiguous. EdisonAPI$Extract all bindings whose keys are >= the given key.This function is always  unambiguous. EdisonAPISplit an associative collection into two sub-collections, containing those bindings whose keys are <# the given key and those which are >=.This function is always  unambiguous. EdisonAPISplit an associative collection into two sub-collections, containing those bindings whose keys are <=# the given key and those which are >.This function is always  unambiguous. EdisonAPISplit an associative collection into two sub-collections, containing those bindings whose keys are <# the given key and those which are >. All bindings with keys equal to the given key are discarded.This function is always  unambiguous. EdisonAPI7The root class of the associative collection hierarchy. EdisonAPI!The empty associative collection.This function is always  unambiguous. EdisonAPI7Create an associative collection with a single binding.This function is always  unambiguous. EdisonAPICreate an associative collection from a list of bindings. Which element and key are kept in the case of duplicate keys is unspecified.This function is  ambiguous at finite map types if the sequence contains more than one equivalent key. Otherwise it is  unambiguous. EdisonAPI>Add a binding to an associative collection. For finite maps, 8 keeps the new element in the case of duplicate keys.This function is  unambiguous. EdisonAPIAdd a sequence of bindings to a collection. For finite maps, which key and which element are kept in the case of duplicates is unspecified. However, if a key appears in the sequence and in the map, (one of) the elements in the list will be given preference.This function is  ambiguous at finite map types if the sequence contains more than one equivalent key. Otherwise it is  unambiguous. EdisonAPIMerge two associative collections. For finite maps, which element to keep in the case of duplicate keys is unspecified.This function is  ambiguous at finite map types if the map keys are not disjoint. Otherwise it is  unambiguous. EdisonAPIMerge a sequence of associative collections. Which element to keep in the case of duplicate keys is unspecified.This function is  ambiguous at finite map types if the map keys are not mutually disjoint. Otherwise it is  unambiguous. EdisonAPIDelete one binding with the given key, or leave the associative collection unchanged if it does not contain the key. For bag-like associative collections, it is unspecified which binding will be removed.This function is  ambiguous at finite relation types if the key appears more than once in the relation. Otherwise it is  unambiguous. EdisonAPIDelete all bindings with the given key, or leave the associative collection unchanged if it does not contain the key.This function is always  unambiguous. EdisonAPIDelete a single occurrence of each of the given keys from an associative collection. For bag-like associative collections containing duplicate keys, it is unspecified which bindings will be removed.This function is  ambiguous at finite relation types if any key appears both in the sequence and in the finite relation AND the number of occurrences in the sequence is less than the number of occurrences in the finite relation. Otherwise it is  unambiguous. EdisonAPI1Test whether the associative collection is empty.Axioms: null m = (size m == 0)This function is always  unambiguous. EdisonAPI?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab_]`! #"$%'()&\^*+,-.0/123456789:;EFGHIJKLMNO<=>?XY@ABCDPQRSTUVWZcdefghijklmnopqr./012345stuvFGwH*+,-@AYxyz{|}~]$%XZ[_&\tsvfghijklm{}~opqr./012345_]$%FGwHJ*+,-@AXYZ[\&(EdisonAPI-1.3.3.1-G7JdMWpFwTpGPYGlZeTbzuData.Edison.PreludeData.Edison.SeqData.Edison.Seq.ListSeqData.Edison.CollData.Edison.Coll.UtilsData.Edison.AssocData.Edison.Sym Data.EdisonMeasuredmeasureReversibleHashunhash UniqueHashHashhashrunFail_$fMonadFailFail $fFunctorFail$fApplicativeFail $fMonadFailSequencelconsrconsfromListcopylviewlheadlheadMltailltailMrviewrheadrheadMrtailrtailMnullsizetoListconcatreverse reverseOntofoldfold'fold1fold1'foldrfoldr'foldlfoldl'foldr1foldr1'foldl1foldl1'reducerreducer'reducelreducel'reduce1reduce1'takedropsplitAtsubseqfilter partition takeWhile dropWhile splitWhileinBoundslookuplookupMlookupWithDefaultupdateadjust mapWithIndexfoldrWithIndexfoldrWithIndex'foldlWithIndexfoldlWithIndex'zipzip3zipWithzipWith3unzipunzip3 unzipWith unzipWith3strict strictWithstructuralInvariant instanceNamemap singleton concatMapemptyappendSeq moduleName $fSequence[]OrdSetSet fromSeqWith insertWith insertSeqWithunionlunionr unionWith unionSeqWithintersectionWithOrdCollminViewminElemmaxViewmaxElemtoOrdSequnsafeMapMonotonicColltoSeq lookupAllOrdSetXSetX intersection differencesymmetricDifference properSubsetsubsetOrdCollX deleteMin deleteMaxunsafeInsertMinunsafeInsertMaxunsafeFromOrdSeq unsafeAppendfilterLTfilterLEfilterGTfilterGEpartitionLT_GEpartitionLE_GTpartitionLT_GTCollXfromSequnionSeqinsert insertSeqdelete deleteAll deleteSeqmembercountunion insertList unionList deleteListunsafeFromOrdList lookupList toOrdList fromListWithinsertListWith unionListWith mapPartialunionMap OrdFiniteMap FiniteMap unionWithKeyunionSeqWithKeyintersectionWithKeyOrdAssocminViewWithKeyminElemWithKeymaxViewWithKeymaxElemWithKey foldrWithKey foldrWithKey' foldlWithKey foldlWithKey'Assockeys mapWithKey foldWithKey foldWithKey' filterWithKeypartitionWithKey OrdFiniteMapX FiniteMapXfromSeqWithKey insertWithKeyinsertSeqWithKeysubmapByproperSubmapBy sameMapBy OrdAssocXAssocXlookupAndDeletelookupAndDeleteMlookupAndDeleteAll adjustAlladjustOrInsertadjustAllOrInsertadjustOrDeleteadjustOrDeleteAllelementssubmap properSubmapsameMap elementsListfromListWithKeyinsertListWithKeykeysListunionListWithKey<||>++!|=\\/\\/FailbaseControl.Monad.Failfailghc-prim GHC.TypesTrueFalse GHC.ClassesEq