-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Various set implementations in Haskell
--   
--   This also includes overloaded functions for common set operations. See
--   <tt>Data.Set.Class</tt>.
@package sets
@version 0.0.4.1


-- | Orient the ordering of your set by a different index, by first
--   supplying a function <tt>(a -&gt; k)</tt> to weigh each element. This
--   module simply leverages <tt>Data.Map</tt>, and does not use a novel
--   data type.
--   
--   Note: This data type can only have one element per distinguished
--   weight. For oriented multisets, use
--   <tt>Data.Set.Ordered.Many.With.SetsWith</tt>.
module Data.Set.Ordered.Unique.With
newtype SetWith k a
SetWith :: (a -> k, Map k a) -> SetWith k a
[unSetWith] :: SetWith k a -> (a -> k, Map k a)
(\\) :: Ord k => SetWith k a -> SetWith k a -> SetWith k a
null :: SetWith k a -> Bool
size :: SetWith k a -> Int
member :: Ord k => a -> SetWith k a -> Bool
notMember :: Ord k => a -> SetWith k a -> Bool
lookupLT :: Ord k => a -> SetWith k a -> Maybe a
lookupGT :: Ord k => a -> SetWith k a -> Maybe a
lookupLE :: Ord k => a -> SetWith k a -> Maybe a
lookupGE :: Ord k => a -> SetWith k a -> Maybe a
isSubsetOf :: (Eq a, Ord k) => SetWith k a -> SetWith k a -> Bool
isProperSubsetOf :: (Eq a, Ord k) => SetWith k a -> SetWith k a -> Bool
empty :: (a -> k) -> SetWith k a
singleton :: Ord k => (a -> k) -> a -> SetWith k a
insert :: Ord k => a -> SetWith k a -> SetWith k a
delete :: Ord k => a -> SetWith k a -> SetWith k a
union :: Ord k => SetWith k a -> SetWith k a -> SetWith k a
unions :: Ord k => (a -> k) -> [SetWith k a] -> SetWith k a
difference :: Ord k => SetWith k a -> SetWith k a -> SetWith k a
intersection :: Ord k => SetWith k a -> SetWith k a -> SetWith k a
filter :: (a -> Bool) -> SetWith k a -> SetWith k a
partition :: (a -> Bool) -> SetWith k a -> (SetWith k a, SetWith k a)
split :: Ord k => a -> SetWith k a -> (SetWith k a, SetWith k a)
splitMember :: Ord k => a -> SetWith k a -> (SetWith k a, Bool, SetWith k a)
splitRoot :: Ord k => SetWith k a -> [SetWith k a]
lookupIndex :: Ord k => a -> SetWith k a -> Maybe Int
findIndex :: Ord k => a -> SetWith k a -> Int
elemAt :: Int -> SetWith k a -> a
deleteAt :: Int -> SetWith k a -> SetWith k a
map :: (a -> b) -> (b -> a) -> SetWith k a -> SetWith k b
mapMaybe :: (a -> Maybe b) -> (b -> a) -> SetWith k a -> SetWith k b
foldr :: (a -> b -> b) -> b -> SetWith k a -> b
foldl :: (b -> a -> b) -> b -> SetWith k a -> b
foldr' :: (a -> b -> b) -> b -> SetWith k a -> b
foldl' :: (b -> a -> b) -> b -> SetWith k a -> b
fold :: (a -> b -> b) -> b -> SetWith k a -> b
findMin :: SetWith k a -> a
findMax :: SetWith k a -> a
deleteMin :: SetWith k a -> SetWith k a
deleteMax :: SetWith k a -> SetWith k a
deleteFindMin :: SetWith k a -> (a, SetWith k a)
deleteFindMax :: SetWith k a -> (a, SetWith k a)
minView :: SetWith k a -> Maybe (a, SetWith k a)
maxView :: SetWith k a -> Maybe (a, SetWith k a)
elems :: SetWith k a -> [a]
toList :: SetWith k a -> (a -> k, [a])
fromList :: (Ord k, Foldable f) => (a -> k) -> f a -> SetWith k a
toAscList :: SetWith k a -> [a]
toDescList :: SetWith k a -> [a]
fromAscList :: Eq k => (a -> k) -> [a] -> SetWith k a
fromDistinctAscList :: (a -> k) -> [a] -> SetWith k a
showTree :: (Show k, Show a) => SetWith k a -> String
showTreeWith :: (k -> a -> String) -> Bool -> Bool -> SetWith k a -> String
instance (GHC.Classes.Ord k, GHC.Base.Monoid k) => GHC.Base.Monoid (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Functor.Invariant.Invariant (Data.Set.Ordered.Unique.With.SetWith k)
instance Data.Foldable.Foldable (Data.Set.Ordered.Unique.With.SetWith k)

module Data.Set.Ordered.Unique.Finite
newtype FiniteSet a
FiniteSet :: (Set a, Set a) -> FiniteSet a
[unFiniteSet] :: FiniteSet a -> (Set a, Set a)

-- | <i>O(n+m)</i>
(\\) :: Ord a => FiniteSet a -> FiniteSet a -> FiniteSet a

-- | <i>O(1)</i>
null :: Eq a => FiniteSet a -> Bool

-- | <i>O(1)</i>
size :: FiniteSet a -> Int

-- | <i>O(log n)</i>
member :: Ord a => a -> FiniteSet a -> Bool

-- | <i>O(log n)</i>
notMember :: Ord a => a -> FiniteSet a -> Bool

-- | <i>O(n+m+t1+t2)</i>
isSubsetOf :: Ord a => FiniteSet a -> FiniteSet a -> Bool

-- | <i>O(n+m+t1+t2)</i>
isProperSubsetOf :: Ord a => FiniteSet a -> FiniteSet a -> Bool

-- | <i>O(1)</i>
empty :: Set a -> FiniteSet a
total :: FiniteSet a -> Set a

-- | <i>O(1)</i>
singleton :: Set a -> a -> FiniteSet a

-- | <i>O(log n)</i>
insert :: Ord a => a -> FiniteSet a -> FiniteSet a

-- | <i>O(log n)</i>
delete :: Ord a => a -> FiniteSet a -> FiniteSet a

-- | <i>O(n+m)</i>
union :: Ord a => FiniteSet a -> FiniteSet a -> FiniteSet a

-- | <i>O(n+m)</i>
difference :: Ord a => FiniteSet a -> FiniteSet a -> FiniteSet a

-- | <i>O(n+m)</i>
intersection :: Ord a => FiniteSet a -> FiniteSet a -> FiniteSet a

-- | /O(n+t)
complement :: Ord a => FiniteSet a -> FiniteSet a

-- | <i>O(n)</i>
filter :: (a -> Bool) -> FiniteSet a -> FiniteSet a

-- | <i>O(n)</i> - Guaranteed to be disjoint
partition :: (a -> Bool) -> FiniteSet a -> (FiniteSet a, FiniteSet a)

-- | <i>O(n)</i>
map :: Ord b => (a -> b) -> FiniteSet a -> FiniteSet b
instance GHC.Show.Show a => GHC.Show.Show (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Set.Ordered.Unique.Finite.FiniteSet a)

module Data.Set.Ordered.Unique
type OUSet = Set


-- | Unique, unordered sets. The semantics for "unordering" is based on the
--   idea that we will not know what order the elements are in at any
--   point, and we are free to re-order elements in any way.
module Data.Set.Unordered.Unique

-- | Pronounced "Unordered Unique Set"
newtype UUSet a
UUSet :: [a] -> UUSet a
[unUUSet] :: UUSet a -> [a]
(\\) :: Eq a => UUSet a -> UUSet a -> UUSet a

-- | <i>O(1)</i>
null :: Eq a => UUSet a -> Bool

-- | <i>O(n)</i>
size :: UUSet a -> Int

-- | <i>O(n)</i>
member :: Eq a => a -> UUSet a -> Bool

-- | <i>O(n)</i>
notMember :: Eq a => a -> UUSet a -> Bool

-- | <i>O(n)</i>
lookup :: Eq a => a -> UUSet a -> Maybe a

-- | <i>O(n*m)</i>
isSubsetOf :: Eq a => UUSet a -> UUSet a -> Bool

-- | <i>O(n*(m^2))</i>
isProperSubsetOf :: Eq a => UUSet a -> UUSet a -> Bool

-- | <i>O(1)</i>
empty :: UUSet a

-- | <i>O(1)</i>
singleton :: a -> UUSet a

-- | <i>O(n)</i>
insert :: Eq a => a -> UUSet a -> UUSet a

-- | <i>O(n)</i>
delete :: Eq a => a -> UUSet a -> UUSet a

-- | <i>O(n*m)</i>
union :: Eq a => UUSet a -> UUSet a -> UUSet a

-- | <i>O(n*m)</i>
difference :: Eq a => UUSet a -> UUSet a -> UUSet a

-- | <i>O(n*m)</i>
intersection :: Eq a => UUSet a -> UUSet a -> UUSet a

-- | <i>O(n)</i>
filter :: (a -> Bool) -> UUSet a -> UUSet a

-- | <i>O(n)</i> - Guaranteed to be disjoint
partition :: (a -> Bool) -> UUSet a -> (UUSet a, UUSet a)

-- | <i>O(n)</i>
map :: (a -> b) -> UUSet a -> UUSet b

-- | <i>O(?)</i>
mapMaybe :: (a -> Maybe b) -> UUSet a -> UUSet b
instance GHC.Show.Show a => GHC.Show.Show (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Base.Functor Data.Set.Unordered.Unique.UUSet
instance Data.Mergeable.Mergeable Data.Set.Unordered.Unique.UUSet
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Set.Unordered.Unique.UUSet a)

module Data.Set.Unordered.Many

-- | Unordered sets with duplicate elements. The semantics for "unordering"
--   is based on the idea that we will not know what order the elements are
--   in at any point, and we are free to re-order elements in any way.
--   
--   Most binary functions are algorithmically heavier on the right
--   arguments.
--   
--   Pronounced "Unordered Many Set"
newtype UMSet a
UMSet :: [a] -> UMSet a
[unUMSet] :: UMSet a -> [a]
(\\) :: Eq a => UMSet a -> UMSet a -> UMSet a

-- | <i>O(1)</i>
null :: Eq a => UMSet a -> Bool

-- | <i>O(n)</i>
size :: UMSet a -> Int

-- | <i>O(n)</i>
member :: Eq a => a -> UMSet a -> Bool

-- | <i>O(n)</i>
notMember :: Eq a => a -> UMSet a -> Bool

-- | <i>O(n)</i>
lookup :: Eq a => a -> UMSet a -> Maybe a

-- | <i>O(n*m)</i>
isSubsetOf :: Eq a => UMSet a -> UMSet a -> Bool

-- | <i>O(n*(m^3))</i>
isProperSubsetOf :: Eq a => UMSet a -> UMSet a -> Bool

-- | <i>O(1)</i>
empty :: UMSet a

-- | <i>O(1)</i>
singleton :: a -> UMSet a

-- | <i>O(1)</i>
insert :: a -> UMSet a -> UMSet a

-- | <i>O(n)</i>
delete :: Eq a => a -> UMSet a -> UMSet a

-- | <i>O(n)</i>
union :: Eq a => UMSet a -> UMSet a -> UMSet a

-- | <i>O(n*m)</i>
difference :: Eq a => UMSet a -> UMSet a -> UMSet a

-- | <i>O(n*(m^4))</i> - Combines all elements of both
intersection :: Eq a => UMSet a -> UMSet a -> UMSet a

-- | <i>O(n)</i>
filter :: (a -> Bool) -> UMSet a -> UMSet a

-- | <i>O(n)</i>
partition :: (a -> Bool) -> UMSet a -> (UMSet a, UMSet a)

-- | <i>O(n)</i>
map :: (a -> b) -> UMSet a -> UMSet b

-- | <i>O(?)</i>
mapMaybe :: (a -> Maybe b) -> UMSet a -> UMSet b
instance GHC.Show.Show a => GHC.Show.Show (Data.Set.Unordered.Many.UMSet a)
instance GHC.Base.Functor Data.Set.Unordered.Many.UMSet
instance Data.Mergeable.Mergeable Data.Set.Unordered.Many.UMSet
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Set.Unordered.Many.UMSet a)

module Data.Set.Ordered.Many

-- | Ordered sets with duplicate elements.
newtype OMSet a
OMSet :: [a] -> OMSet a
[unOMSet] :: OMSet a -> [a]
(\\) :: Eq a => OMSet a -> OMSet a -> OMSet a

-- | <i>O(1)</i>
null :: Eq a => OMSet a -> Bool

-- | <i>O(n)</i>
size :: OMSet a -> Int

-- | <i>O(n)</i>
member :: Eq a => a -> OMSet a -> Bool

-- | <i>O(n)</i>
notMember :: Eq a => a -> OMSet a -> Bool

-- | <i>O(n)</i>
lookup :: Eq a => a -> OMSet a -> Maybe a

-- | <i>O(n*m)</i>
isSubsetOf :: Eq a => OMSet a -> OMSet a -> Bool

-- | <i>O(n*(m^3))</i>
isProperSubsetOf :: Eq a => OMSet a -> OMSet a -> Bool

-- | <i>O(1)</i>
empty :: OMSet a

-- | <i>O(1)</i>
singleton :: a -> OMSet a

-- | <i>O(n)</i>
insert :: Ord a => a -> OMSet a -> OMSet a

-- | <i>O(n)</i>
delete :: Eq a => a -> OMSet a -> OMSet a

-- | <i>O(n+m)</i>
union :: Sorting a => OMSet a -> OMSet a -> OMSet a

-- | <i>O(n*m)</i>
difference :: Eq a => OMSet a -> OMSet a -> OMSet a

-- | <i>O(min(n,m))</i> - Combines all elements of both
intersection :: Ord a => OMSet a -> OMSet a -> OMSet a

-- | <i>O(n)</i>
filter :: (a -> Bool) -> OMSet a -> OMSet a

-- | <i>O(n)</i>
partition :: (a -> Bool) -> OMSet a -> (OMSet a, OMSet a)

-- | <i>O(n)</i>
map :: (a -> b) -> OMSet a -> OMSet b

-- | <i>O(?)</i>
mapMaybe :: (a -> Maybe b) -> OMSet a -> OMSet b
instance Control.Monad.Fix.MonadFix Data.Set.Ordered.Many.OMSet
instance Data.Traversable.Traversable Data.Set.Ordered.Many.OMSet
instance Data.Foldable.Foldable Data.Set.Ordered.Many.OMSet
instance GHC.Base.Monad Data.Set.Ordered.Many.OMSet
instance GHC.Base.Applicative Data.Set.Ordered.Many.OMSet
instance GHC.Base.Functor Data.Set.Ordered.Many.OMSet
instance GHC.Show.Show a => GHC.Show.Show (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Set.Ordered.Many.OMSet a)
instance Data.Mergeable.Mergeable Data.Set.Ordered.Many.OMSet


-- | Convenience operators overloaded for arbitrary use. There are no laws
--   associated with these classes, just duck-typed so we don't have to use
--   the qualified versions of each function.
module Data.Set.Class
newtype Union a
Union :: a -> Union a
[unUnion] :: Union a -> a
newtype Intersection a
Intersection :: a -> Intersection a
[unIntersection] :: Intersection a -> a
newtype XUnion a
XUnion :: a -> XUnion a
[unXUnion] :: XUnion a -> a
class HasUnion s
union :: HasUnion s => s -> s -> s
unions :: (Foldable f, HasUnion s, HasEmpty s) => f s -> s
class HasDifference s
difference :: HasDifference s => s -> s -> s
(\\) :: HasDifference s => s -> s -> s
class HasIntersection s
intersection :: HasIntersection s => s -> s -> s
intersections :: (Foldable f, HasIntersection s, HasTotal s) => f s -> s
class HasXUnion s
xunion :: HasXUnion s => s -> s -> s
class HasComplement s
complement :: HasComplement s => s -> s
class HasSingleton a s
singleton :: HasSingleton a s => a -> s
class HasSingletonWith k a s
singletonWith :: HasSingletonWith k a s => k -> a -> s
class HasDelete a s
delete :: HasDelete a s => a -> s -> s
class HasInsert a s
insert :: HasInsert a s => a -> s -> s
class HasInsertWith k a s
insertWith :: HasInsertWith k a s => k -> a -> s -> s
class HasEmpty s
empty :: HasEmpty s => s
class HasEmptyWith k s
emptyWith :: HasEmptyWith k s => k -> s
class HasTotal s
total :: HasTotal s => s
class HasTotalWith k s
totalWith :: HasTotalWith k s => k -> s
class HasSize s
size :: HasSize s => s -> Int
class CanBeSubset s
isSubsetOf :: CanBeSubset s => s -> s -> Bool
class CanBeProperSubset s
isProperSubsetOf :: CanBeProperSubset s => s -> s -> Bool
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Set.Class.XUnion a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Set.Class.XUnion a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Set.Class.Intersection a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Set.Class.Intersection a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Set.Class.Union a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Set.Class.Union a)
instance Data.Set.Class.HasUnion a => Data.Set.Class.HasUnion (Data.Set.Class.Union a)
instance Data.Set.Class.HasDifference a => Data.Set.Class.HasDifference (Data.Set.Class.Union a)
instance Data.Set.Class.HasIntersection a => Data.Set.Class.HasIntersection (Data.Set.Class.Union a)
instance Data.Set.Class.HasComplement a => Data.Set.Class.HasComplement (Data.Set.Class.Union a)
instance Data.Set.Class.HasSingleton x a => Data.Set.Class.HasSingleton x (Data.Set.Class.Union a)
instance Data.Set.Class.HasSingletonWith k x a => Data.Set.Class.HasSingletonWith k x (Data.Set.Class.Union a)
instance Data.Set.Class.HasInsert x a => Data.Set.Class.HasInsert x (Data.Set.Class.Union a)
instance Data.Set.Class.HasInsertWith k x a => Data.Set.Class.HasInsertWith k x (Data.Set.Class.Union a)
instance Data.Set.Class.HasDelete x a => Data.Set.Class.HasDelete x (Data.Set.Class.Union a)
instance Data.Set.Class.HasEmpty a => Data.Set.Class.HasEmpty (Data.Set.Class.Union a)
instance Data.Set.Class.HasEmptyWith k a => Data.Set.Class.HasEmptyWith k (Data.Set.Class.Union a)
instance Data.Set.Class.HasTotal a => Data.Set.Class.HasTotal (Data.Set.Class.Union a)
instance Data.Set.Class.HasTotalWith k a => Data.Set.Class.HasTotalWith k (Data.Set.Class.Union a)
instance Data.Set.Class.HasSize a => Data.Set.Class.HasSize (Data.Set.Class.Union a)
instance Data.Set.Class.CanBeSubset a => Data.Set.Class.CanBeSubset (Data.Set.Class.Union a)
instance Data.Set.Class.CanBeProperSubset a => Data.Set.Class.CanBeProperSubset (Data.Set.Class.Union a)
instance Data.Set.Class.HasUnion a => Data.Set.Class.HasUnion (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasDifference a => Data.Set.Class.HasDifference (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasIntersection a => Data.Set.Class.HasIntersection (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasComplement a => Data.Set.Class.HasComplement (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasSingleton x a => Data.Set.Class.HasSingleton x (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasSingletonWith k x a => Data.Set.Class.HasSingletonWith k x (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasInsert x a => Data.Set.Class.HasInsert x (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasInsertWith k x a => Data.Set.Class.HasInsertWith k x (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasDelete x a => Data.Set.Class.HasDelete x (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasEmpty a => Data.Set.Class.HasEmpty (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasEmptyWith k a => Data.Set.Class.HasEmptyWith k (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasTotal a => Data.Set.Class.HasTotal (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasTotalWith k a => Data.Set.Class.HasTotalWith k (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasSize a => Data.Set.Class.HasSize (Data.Set.Class.Intersection a)
instance Data.Set.Class.CanBeSubset a => Data.Set.Class.CanBeSubset (Data.Set.Class.Intersection a)
instance Data.Set.Class.CanBeProperSubset a => Data.Set.Class.CanBeProperSubset (Data.Set.Class.Intersection a)
instance Data.Set.Class.HasUnion a => Data.Set.Class.HasUnion (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasDifference a => Data.Set.Class.HasDifference (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasIntersection a => Data.Set.Class.HasIntersection (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasComplement a => Data.Set.Class.HasComplement (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasSingleton x a => Data.Set.Class.HasSingleton x (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasSingletonWith k x a => Data.Set.Class.HasSingletonWith k x (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasInsert x a => Data.Set.Class.HasInsert x (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasInsertWith k x a => Data.Set.Class.HasInsertWith k x (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasDelete x a => Data.Set.Class.HasDelete x (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasEmpty a => Data.Set.Class.HasEmpty (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasEmptyWith k a => Data.Set.Class.HasEmptyWith k (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasTotal a => Data.Set.Class.HasTotal (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasTotalWith k a => Data.Set.Class.HasTotalWith k (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasSize a => Data.Set.Class.HasSize (Data.Set.Class.XUnion a)
instance Data.Set.Class.CanBeSubset a => Data.Set.Class.CanBeSubset (Data.Set.Class.XUnion a)
instance Data.Set.Class.CanBeProperSubset a => Data.Set.Class.CanBeProperSubset (Data.Set.Class.XUnion a)
instance Data.Set.Class.HasUnion s => Data.Commutative.Commutative (Data.Set.Class.Union s)
instance (Data.Set.Class.HasUnion s, Data.Set.Class.HasEmpty s) => GHC.Base.Monoid (Data.Set.Class.Union s)
instance Data.Set.Class.HasIntersection s => Data.Commutative.Commutative (Data.Set.Class.Intersection s)
instance (Data.Set.Class.HasIntersection s, Data.Set.Class.HasTotal s) => GHC.Base.Monoid (Data.Set.Class.Intersection s)
instance (Data.Set.Class.HasUnion s, Data.Set.Class.HasIntersection s, Data.Set.Class.HasDifference s) => Data.Set.Class.HasXUnion s
instance (Data.Set.Class.HasXUnion s, Data.Set.Class.HasUnion s, Data.Set.Class.HasIntersection s, Data.Set.Class.HasDifference s) => Data.Commutative.Commutative (Data.Set.Class.XUnion s)
instance (Data.Set.Class.HasXUnion s, Data.Set.Class.HasEmpty s, Data.Set.Class.HasUnion s, Data.Set.Class.HasIntersection s, Data.Set.Class.HasDifference s) => GHC.Base.Monoid (Data.Set.Class.XUnion s)
instance (Data.Commutative.Commutative (Data.Set.Class.Union s), Data.Set.Class.HasEmpty s) => Data.Commutative.CommutativeId (Data.Set.Class.Union s)
instance (Data.Commutative.Commutative (Data.Set.Class.Intersection s), Data.Set.Class.HasTotal s) => Data.Commutative.CommutativeId (Data.Set.Class.Intersection s)
instance GHC.Classes.Ord a => Data.Set.Class.HasUnion (Data.Set.Base.Set a)
instance GHC.Classes.Ord a => Data.Set.Class.HasDifference (Data.Set.Base.Set a)
instance GHC.Classes.Ord a => Data.Set.Class.HasIntersection (Data.Set.Base.Set a)
instance Data.Set.Class.HasSingleton a (Data.Set.Base.Set a)
instance GHC.Classes.Ord a => Data.Set.Class.HasInsert a (Data.Set.Base.Set a)
instance GHC.Classes.Ord a => Data.Set.Class.HasDelete a (Data.Set.Base.Set a)
instance Data.Set.Class.HasEmpty (Data.Set.Base.Set a)
instance Data.Set.Class.HasSize (Data.Set.Base.Set a)
instance GHC.Classes.Ord a => Data.Set.Class.CanBeSubset (Data.Set.Base.Set a)
instance GHC.Classes.Ord a => Data.Set.Class.CanBeProperSubset (Data.Set.Base.Set a)
instance GHC.Classes.Ord k => Data.Set.Class.HasUnion (Data.Map.Base.Map k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasDifference (Data.Map.Base.Map k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasIntersection (Data.Map.Base.Map k a)
instance Data.Set.Class.HasSingletonWith k a (Data.Map.Base.Map k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasInsertWith k a (Data.Map.Base.Map k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasDelete k (Data.Map.Base.Map k a)
instance Data.Set.Class.HasEmpty (Data.Map.Base.Map k a)
instance Data.Set.Class.HasSize (Data.Map.Base.Map k a)
instance (GHC.Classes.Eq k, GHC.Classes.Ord k, GHC.Classes.Eq a) => Data.Set.Class.CanBeSubset (Data.Map.Base.Map k a)
instance (GHC.Classes.Eq k, GHC.Classes.Ord k, GHC.Classes.Eq a) => Data.Set.Class.CanBeProperSubset (Data.Map.Base.Map k a)
instance Data.Set.Class.HasSingleton a [a]
instance Data.Set.Class.HasInsert a [a]
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a [a]
instance Data.Set.Class.HasEmpty [a]
instance Data.Set.Class.HasSize [a]
instance Data.Set.Class.HasSingleton a (Data.Sequence.Seq a)
instance Data.Set.Class.HasEmpty (Data.Sequence.Seq a)
instance Data.Set.Class.HasSize (Data.Sequence.Seq a)
instance Data.Set.Class.HasUnion Data.IntSet.Base.IntSet
instance Data.Set.Class.HasDifference Data.IntSet.Base.IntSet
instance Data.Set.Class.HasIntersection Data.IntSet.Base.IntSet
instance Data.Set.Class.HasSingleton Data.IntSet.Base.Key Data.IntSet.Base.IntSet
instance Data.Set.Class.HasInsert Data.IntSet.Base.Key Data.IntSet.Base.IntSet
instance Data.Set.Class.HasDelete Data.IntSet.Base.Key Data.IntSet.Base.IntSet
instance Data.Set.Class.HasEmpty Data.IntSet.Base.IntSet
instance Data.Set.Class.HasSize Data.IntSet.Base.IntSet
instance Data.Set.Class.CanBeSubset Data.IntSet.Base.IntSet
instance Data.Set.Class.CanBeProperSubset Data.IntSet.Base.IntSet
instance Data.Set.Class.HasUnion (Data.IntMap.Base.IntMap a)
instance Data.Set.Class.HasDifference (Data.IntMap.Base.IntMap a)
instance Data.Set.Class.HasIntersection (Data.IntMap.Base.IntMap a)
instance Data.Set.Class.HasSingletonWith Data.IntSet.Base.Key a (Data.IntMap.Base.IntMap a)
instance Data.Set.Class.HasInsertWith Data.IntSet.Base.Key a (Data.IntMap.Base.IntMap a)
instance Data.Set.Class.HasDelete Data.IntSet.Base.Key (Data.IntMap.Base.IntMap a)
instance Data.Set.Class.HasEmpty (Data.IntMap.Base.IntMap a)
instance Data.Set.Class.HasSize (Data.IntMap.Base.IntMap a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeSubset (Data.IntMap.Base.IntMap a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeProperSubset (Data.IntMap.Base.IntMap a)
instance (Data.Hashable.Class.Hashable a, GHC.Classes.Eq a) => Data.Set.Class.HasUnion (Data.HashSet.HashSet a)
instance (Data.Hashable.Class.Hashable a, GHC.Classes.Eq a) => Data.Set.Class.HasDifference (Data.HashSet.HashSet a)
instance (Data.Hashable.Class.Hashable a, GHC.Classes.Eq a) => Data.Set.Class.HasIntersection (Data.HashSet.HashSet a)
instance Data.Hashable.Class.Hashable a => Data.Set.Class.HasSingleton a (Data.HashSet.HashSet a)
instance (Data.Hashable.Class.Hashable a, GHC.Classes.Eq a) => Data.Set.Class.HasInsert a (Data.HashSet.HashSet a)
instance (Data.Hashable.Class.Hashable a, GHC.Classes.Eq a) => Data.Set.Class.HasDelete a (Data.HashSet.HashSet a)
instance Data.Set.Class.HasEmpty (Data.HashSet.HashSet a)
instance Data.Set.Class.HasSize (Data.HashSet.HashSet a)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Set.Class.HasUnion (Data.HashMap.Base.HashMap k a)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Set.Class.HasDifference (Data.HashMap.Base.HashMap k a)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Set.Class.HasIntersection (Data.HashMap.Base.HashMap k a)
instance Data.Hashable.Class.Hashable k => Data.Set.Class.HasSingletonWith k a (Data.HashMap.Base.HashMap k a)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Set.Class.HasInsertWith k a (Data.HashMap.Base.HashMap k a)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Set.Class.HasDelete k (Data.HashMap.Base.HashMap k a)
instance Data.Set.Class.HasEmpty (Data.HashMap.Base.HashMap k a)
instance Data.Set.Class.HasSize (Data.HashMap.Base.HashMap k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasUnion (Data.Set.Ordered.Unique.With.SetWith k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasDifference (Data.Set.Ordered.Unique.With.SetWith k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasIntersection (Data.Set.Ordered.Unique.With.SetWith k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasSingletonWith (a -> k) a (Data.Set.Ordered.Unique.With.SetWith k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasInsert a (Data.Set.Ordered.Unique.With.SetWith k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasDelete a (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Set.Class.HasEmptyWith (a -> k) (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Set.Class.HasSize (Data.Set.Ordered.Unique.With.SetWith k a)
instance (GHC.Classes.Ord k, GHC.Classes.Eq a) => Data.Set.Class.CanBeSubset (Data.Set.Ordered.Unique.With.SetWith k a)
instance (GHC.Classes.Ord k, GHC.Classes.Eq a) => Data.Set.Class.CanBeProperSubset (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Set.Class.HasUnion (Data.Functor.Contravariant.Predicate a)
instance Data.Set.Class.HasDifference (Data.Functor.Contravariant.Predicate a)
instance Data.Set.Class.HasIntersection (Data.Functor.Contravariant.Predicate a)
instance Data.Set.Class.HasComplement (Data.Functor.Contravariant.Predicate a)
instance GHC.Classes.Eq a => Data.Set.Class.HasSingleton a (Data.Functor.Contravariant.Predicate a)
instance GHC.Classes.Eq a => Data.Set.Class.HasInsert a (Data.Functor.Contravariant.Predicate a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a (Data.Functor.Contravariant.Predicate a)
instance Data.Set.Class.HasEmpty (Data.Functor.Contravariant.Predicate a)
instance Data.Set.Class.HasTotal (Data.Functor.Contravariant.Predicate a)
instance Data.Discrimination.Sorting.Sorting a => Data.Set.Class.HasUnion (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDifference (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasIntersection (Data.Set.Ordered.Many.OMSet a)
instance Data.Set.Class.HasSingleton a (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasInsert a (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a (Data.Set.Ordered.Many.OMSet a)
instance Data.Set.Class.HasEmpty (Data.Set.Ordered.Many.OMSet a)
instance Data.Set.Class.HasSize (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeSubset (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeProperSubset (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasUnion (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDifference (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasIntersection (Data.Set.Unordered.Many.UMSet a)
instance Data.Set.Class.HasSingleton a (Data.Set.Unordered.Many.UMSet a)
instance Data.Set.Class.HasInsert a (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a (Data.Set.Unordered.Many.UMSet a)
instance Data.Set.Class.HasEmpty (Data.Set.Unordered.Many.UMSet a)
instance Data.Set.Class.HasSize (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeSubset (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeProperSubset (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasUnion (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDifference (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasIntersection (Data.Set.Unordered.Unique.UUSet a)
instance Data.Set.Class.HasSingleton a (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasInsert a (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a (Data.Set.Unordered.Unique.UUSet a)
instance Data.Set.Class.HasEmpty (Data.Set.Unordered.Unique.UUSet a)
instance Data.Set.Class.HasSize (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeSubset (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeProperSubset (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasUnion (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasDifference (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasIntersection (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasComplement (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance Data.Set.Class.HasSingletonWith (Data.Set.Base.Set a) a (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasInsert a (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasDelete a (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance Data.Set.Class.HasEmptyWith (Data.Set.Base.Set a) (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance Data.Set.Class.HasTotalWith (Data.Set.Ordered.Unique.Finite.FiniteSet a) (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance Data.Set.Class.HasSize (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance GHC.Classes.Ord a => Data.Set.Class.CanBeSubset (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance GHC.Classes.Ord a => Data.Set.Class.CanBeProperSubset (Data.Set.Ordered.Unique.Finite.FiniteSet a)

module Data.Set.Ordered.Many.With
newtype SetsWith k c a
SetsWith :: (a -> k, Map k (c a)) -> SetsWith k c a
[unSetsWith] :: SetsWith k c a -> (a -> k, Map k (c a))
(\\) :: (Ord k, HasDifference (c a)) => SetsWith k c a -> SetsWith k c a -> SetsWith k c a
null :: SetsWith k c a -> Bool
size :: SetsWith k c a -> Int
member :: Ord k => a -> SetsWith k c a -> Bool
notMember :: Ord k => a -> SetsWith k c a -> Bool
lookupLT :: Ord k => a -> SetsWith k c a -> Maybe (c a)
lookupGT :: Ord k => a -> SetsWith k c a -> Maybe (c a)
lookupLE :: Ord k => a -> SetsWith k c a -> Maybe (c a)
lookupGE :: Ord k => a -> SetsWith k c a -> Maybe (c a)
isSubsetOf :: (Ord k, Eq (c a), CanBeSubset (c a)) => SetsWith k c a -> SetsWith k c a -> Bool
isProperSubsetOf :: (Ord k, Eq (c a), CanBeSubset (c a)) => SetsWith k c a -> SetsWith k c a -> Bool
empty :: (a -> k) -> SetsWith k c a
singleton :: (Ord k, HasUnion (c a), HasSingleton a (c a)) => (a -> k) -> a -> SetsWith k c a
insert :: (Ord k, HasUnion (c a), HasSingleton a (c a)) => a -> SetsWith k c a -> SetsWith k c a
delete :: (Ord k, Eq (c a), HasEmpty (c a), HasDelete a (c a)) => a -> SetsWith k c a -> SetsWith k c a
union :: (Ord k, HasUnion (c a)) => SetsWith k c a -> SetsWith k c a -> SetsWith k c a
difference :: (Ord k, Eq (c a), HasEmpty (c a), HasDifference (c a)) => SetsWith k c a -> SetsWith k c a -> SetsWith k c a
intersection :: (Ord k, Eq (c a), HasEmpty (c a), HasIntersection (c a)) => SetsWith k c a -> SetsWith k c a -> SetsWith k c a
filter :: (Eq (c a), HasEmpty (c a), Witherable c) => (a -> Bool) -> SetsWith k c a -> SetsWith k c a
partition :: (c a -> Bool) -> SetsWith k c a -> (SetsWith k c a, SetsWith k c a)
split :: Ord k => a -> SetsWith k c a -> (SetsWith k c a, SetsWith k c a)
splitMember :: Ord k => a -> SetsWith k c a -> (SetsWith k c a, Bool, SetsWith k c a)
splitRoot :: Ord k => SetsWith k c a -> [SetsWith k c a]
lookupIndex :: Ord k => a -> SetsWith k c a -> Maybe Int
findIndex :: Ord k => a -> SetsWith k c a -> Int
setAt :: Int -> SetsWith k c a -> c a
deleteAt :: Int -> SetsWith k c a -> SetsWith k c a
map :: Functor c => (a -> b) -> (b -> a) -> SetsWith k c a -> SetsWith k c b
mapMaybe :: (Eq (c b), HasEmpty (c b), Witherable c) => (a -> Maybe b) -> (b -> a) -> SetsWith k c a -> SetsWith k c b
foldr :: Foldable c => (a -> b -> b) -> b -> SetsWith k c a -> b
foldl :: Foldable c => (b -> a -> b) -> b -> SetsWith k c a -> b
foldr' :: Foldable c => (a -> b -> b) -> b -> SetsWith k c a -> b
foldl' :: Foldable c => (b -> a -> b) -> b -> SetsWith k c a -> b
fold :: Foldable c => (a -> b -> b) -> b -> SetsWith k c a -> b
findMin :: (Ord a, Foldable c) => SetsWith k c a -> a
findMax :: (Ord a, Foldable c) => SetsWith k c a -> a

-- | Deletes <b>entire set</b> with minimum key
deleteMin :: SetsWith k c a -> SetsWith k c a
deleteMax :: SetsWith k c a -> SetsWith k c a
deleteFindMin :: SetsWith k c a -> (c a, SetsWith k c a)
deleteFindMax :: SetsWith k c a -> (c a, SetsWith k c a)
minView :: SetsWith k c a -> Maybe (c a, SetsWith k c a)
maxView :: SetsWith k c a -> Maybe (c a, SetsWith k c a)
elems :: (HasUnion (c a), HasEmpty (c a)) => SetsWith k c a -> c a
toList :: SetsWith k c a -> (a -> k, [c a])
fromList :: (Ord k, HasSingleton a (c a), HasUnion (c a), Foldable f) => (a -> k) -> f a -> SetsWith k c a
toAscList :: SetsWith k c a -> [c a]
toDescList :: SetsWith k c a -> [c a]
fromAscList :: (Eq k, HasSingleton a (c a)) => (a -> k) -> [a] -> SetsWith k c a
fromDistinctAscList :: HasSingleton a (c a) => (a -> k) -> [a] -> SetsWith k c a
showTree :: (Show k, Show (c a)) => SetsWith k c a -> String
showTreeWith :: (k -> c a -> String) -> Bool -> Bool -> SetsWith k c a -> String
instance GHC.Base.Functor c => Data.Functor.Invariant.Invariant (Data.Set.Ordered.Many.With.SetsWith k c)
instance Data.Foldable.Foldable c => Data.Foldable.Foldable (Data.Set.Ordered.Many.With.SetsWith k c)
instance (GHC.Classes.Eq (c a), GHC.Classes.Eq k) => GHC.Classes.Eq (Data.Set.Ordered.Many.With.SetsWith k c a)
instance (GHC.Classes.Ord k, Data.Set.Class.HasUnion (c a)) => Data.Set.Class.HasUnion (Data.Set.Ordered.Many.With.SetsWith k c a)
instance (GHC.Classes.Ord k, GHC.Classes.Eq (c a), Data.Set.Class.HasEmpty (c a), Data.Set.Class.HasDifference (c a)) => Data.Set.Class.HasDifference (Data.Set.Ordered.Many.With.SetsWith k c a)
instance (GHC.Classes.Ord k, GHC.Classes.Eq (c a), Data.Set.Class.HasEmpty (c a), Data.Set.Class.HasIntersection (c a)) => Data.Set.Class.HasIntersection (Data.Set.Ordered.Many.With.SetsWith k c a)
instance (GHC.Classes.Ord k, Data.Set.Class.HasUnion (c a), Data.Set.Class.HasSingleton a (c a)) => Data.Set.Class.HasSingletonWith (a -> k) a (Data.Set.Ordered.Many.With.SetsWith k c a)
instance (GHC.Classes.Ord k, Data.Set.Class.HasUnion (c a), Data.Set.Class.HasSingleton a (c a)) => Data.Set.Class.HasInsert a (Data.Set.Ordered.Many.With.SetsWith k c a)
instance (GHC.Classes.Ord k, GHC.Classes.Eq (c a), Data.Set.Class.HasEmpty (c a), Data.Set.Class.HasDelete a (c a)) => Data.Set.Class.HasDelete a (Data.Set.Ordered.Many.With.SetsWith k c a)
instance Data.Set.Class.HasEmptyWith (a -> k) (Data.Set.Ordered.Many.With.SetsWith k c a)
instance Data.Set.Class.HasSize (Data.Set.Ordered.Many.With.SetsWith k c a)
instance (GHC.Classes.Ord k, GHC.Classes.Eq (c a), Data.Set.Class.CanBeSubset (c a)) => Data.Set.Class.CanBeSubset (Data.Set.Ordered.Many.With.SetsWith k c a)
instance (GHC.Classes.Ord k, GHC.Classes.Eq (c a), Data.Set.Class.CanBeSubset (c a)) => Data.Set.Class.CanBeProperSubset (Data.Set.Ordered.Many.With.SetsWith k c a)