An efficient implementation of sets.

This module is intended to be imported qualified, to avoid name clashes with Prelude functions. eg.

  import Data.Set as Set

The implementation of Set is based on size balanced binary trees (or trees of bounded balance) as described by:

• Stephen Adams, "Efficient sets: a balancing act", Journal of Functional Programming 3(4):553-562, October 1993, http://www.swiss.ai.mit.edu/~adams/BB.
• J. Nievergelt and E.M. Reingold, "Binary search trees of bounded balance", SIAM journal of computing 2(1), March 1973.

Note that the implementation is left-biased -- the elements of a first argument are always perferred to the second, for example in union or insert. Of course, left-biasing can only be observed when equality is an equivalence relation instead of structural equality.

O(n*log n). map 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

mapMonotonic f s == map 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] 
                     ==> mapMonotonic f s == map f s
     where ls = toList s

O(log n). Delete and find the minimal element.

 deleteFindMin set = (findMin set, deleteMin set)

O(log n). Delete and find the maximal element.

 deleteFindMax set = (findMax set, deleteMax set)

O(n). The expression (showTreeWith hang wide map) shows the tree that implements the set. If hang is True, a hanging tree is shown otherwise a rotated tree is shown. If wide is True, an extra wide version is shown.

 Set> putStrLn $ showTreeWith True False $ fromDistinctAscList [1..5]
 4
 +--2
 |  +--1
 |  +--3
 +--5
 
 Set> putStrLn $ showTreeWith True True $ fromDistinctAscList [1..5]
 4
 |
 +--2
 |  |
 |  +--1
 |  |
 |  +--3
 |
 +--5
 
 Set> putStrLn $ showTreeWith False True $ fromDistinctAscList [1..5]
 +--5
 |
 4
 |
 |  +--3
 |  |
 +--2
    |
    +--1