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


-- | Ducktyped set interface for Haskell containers.
--   
--   Please see the README on Github at
--   <a>https://github.com/athanclark/sets#readme</a>
@package sets
@version 0.0.6.2

module Data.Set.Ordered.Many

-- | Ordered sets with duplicate elements.
newtype OMSet a
OMSet :: Vector a -> OMSet a
[unOMSet] :: OMSet a -> Vector a
(\\) :: Eq a => OMSet a -> OMSet a -> OMSet a
null :: Eq a => OMSet a -> Bool
size :: OMSet a -> Int
member :: Eq a => a -> OMSet a -> Bool
notMember :: Eq a => a -> OMSet a -> Bool
lookup :: Eq a => a -> OMSet a -> Maybe a
isSubsetOf :: Eq a => OMSet a -> OMSet a -> Bool
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(min n m)</i>
union :: Ord 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 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
instance (Test.QuickCheck.Arbitrary.Arbitrary a, GHC.Classes.Ord a, GHC.Show.Show a) => Test.QuickCheck.Arbitrary.Arbitrary (Data.Set.Ordered.Many.OMSet a)
instance Control.Monad.Base.MonadBase Test.QuickCheck.Gen.Gen Test.QuickCheck.Gen.Gen

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

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 :: 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)


-- | 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 :: 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.Base.Monoid k, GHC.Classes.Ord k) => GHC.Base.Monoid (Data.Set.Ordered.Unique.With.SetWith k a)
instance (GHC.Base.Semigroup k, GHC.Classes.Ord k) => GHC.Base.Semigroup (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Foldable.Foldable (Data.Set.Ordered.Unique.With.SetWith k)

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 :: 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 :: 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)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Set.Unordered.Many.UMSet a)


-- | 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 :: 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)
instance (Test.QuickCheck.Arbitrary.Arbitrary a, GHC.Classes.Eq a) => Test.QuickCheck.Arbitrary.Arbitrary (Data.Set.Unordered.Unique.UUSet a)
instance Control.Monad.Base.MonadBase Test.QuickCheck.Gen.Gen Test.QuickCheck.Gen.Gen


-- | 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
class HasUnion s
union :: HasUnion s => s -> s -> s
unions :: (Foldable f, Monoid (Union s)) => f s -> s
unions1 :: (Foldable1 f, Semigroup (Union s)) => f s -> s
newtype Union a
Union :: a -> Union a
[unUnion] :: Union a -> a
class HasIntersection s
intersection :: HasIntersection s => s -> s -> s
intersections :: (Foldable f, Monoid (Intersection s)) => f s -> s
intersections1 :: (Foldable1 f, Semigroup (Intersection s)) => f s -> s
newtype Intersection a
Intersection :: a -> Intersection a
[unIntersection] :: Intersection a -> a
class HasDifference s
difference :: HasDifference s => s -> s -> s
(\\) :: HasDifference s => s -> s -> s
class HasXUnion s
xunion :: HasXUnion s => s -> s -> s
xunions :: (Foldable f, Monoid (XUnion s)) => f s -> s
xunions1 :: (Foldable1 f, Semigroup (XUnion s)) => f s -> s
newtype XUnion a
XUnion :: a -> XUnion a
[unXUnion] :: XUnion a -> a
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
fromFoldable :: (Foldable f, HasInsert a s, HasEmpty s) => f a -> s
fromFoldableWithKey :: (FoldableWithKey f, HasInsertWith (Key f) a s, HasEmpty s) => f a -> s
fromFoldable1 :: (Foldable1 f, HasSingleton a s, Semigroup (Union s)) => f a -> s
fromFoldable1WithKey :: (FoldableWithKey1 f, HasSingletonWith (Key f) a s, Semigroup (Union s)) => f a -> s
instance Data.Traversable.Traversable Data.Set.Class.XUnion
instance Data.Foldable.Foldable Data.Set.Class.XUnion
instance GHC.Base.Functor Data.Set.Class.XUnion
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Set.Class.XUnion a)
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 Data.Traversable.Traversable Data.Set.Class.Intersection
instance Data.Foldable.Foldable Data.Set.Class.Intersection
instance GHC.Base.Functor Data.Set.Class.Intersection
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Set.Class.Intersection 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 Data.Traversable.Traversable Data.Set.Class.Union
instance Data.Foldable.Foldable Data.Set.Class.Union
instance GHC.Base.Functor Data.Set.Class.Union
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Set.Class.Union 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 GHC.Classes.Ord a => Data.Set.Class.CanBeProperSubset (Data.Set.Internal.Set a)
instance (GHC.Classes.Eq k, GHC.Classes.Ord k, GHC.Classes.Eq a) => Data.Set.Class.CanBeProperSubset (Data.Map.Internal.Map k a)
instance Data.Set.Class.CanBeProperSubset Data.IntSet.Internal.IntSet
instance GHC.Classes.Eq a => Data.Set.Class.CanBeProperSubset (Data.IntMap.Internal.IntMap a)
instance (GHC.Classes.Ord k, GHC.Classes.Eq a) => Data.Set.Class.CanBeProperSubset (Data.Set.Ordered.Unique.With.SetWith k a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeProperSubset (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeProperSubset (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeProperSubset (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Ord a => Data.Set.Class.CanBeProperSubset (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance GHC.Classes.Ord a => Data.Set.Class.CanBeSubset (Data.Set.Internal.Set a)
instance (GHC.Classes.Eq k, GHC.Classes.Ord k, GHC.Classes.Eq a) => Data.Set.Class.CanBeSubset (Data.Map.Internal.Map k a)
instance Data.Set.Class.CanBeSubset Data.IntSet.Internal.IntSet
instance GHC.Classes.Eq a => Data.Set.Class.CanBeSubset (Data.IntMap.Internal.IntMap 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.Eq a => Data.Set.Class.CanBeSubset (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeSubset (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.CanBeSubset (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Ord a => Data.Set.Class.CanBeSubset (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance Data.Set.Class.HasSize (Data.Set.Internal.Set a)
instance Data.Set.Class.HasSize (Data.Map.Internal.Map k a)
instance Data.Set.Class.HasSize [a]
instance Data.Set.Class.HasSize (Data.Vector.Vector a)
instance Data.Set.Class.HasSize (Data.Sequence.Internal.Seq a)
instance Data.Set.Class.HasSize Data.IntSet.Internal.IntSet
instance Data.Set.Class.HasSize (Data.IntMap.Internal.IntMap a)
instance Data.Set.Class.HasSize (Data.HashSet.Base.HashSet a)
instance Data.Set.Class.HasSize (Data.HashMap.Base.HashMap k a)
instance Data.Set.Class.HasSize (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Set.Class.HasSize (Data.Set.Ordered.Many.OMSet a)
instance Data.Set.Class.HasSize (Data.Set.Unordered.Many.UMSet a)
instance Data.Set.Class.HasSize (Data.Set.Unordered.Unique.UUSet a)
instance Data.Set.Class.HasSize (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.HasIntersection s, Data.Set.Class.HasTotal s) => GHC.Base.Monoid (Data.Set.Class.Intersection s)
instance (Data.Commutative.Commutative (Data.Set.Class.Intersection s), Data.Set.Class.HasTotal s) => Data.Commutative.CommutativeId (Data.Set.Class.Intersection s)
instance Data.Set.Class.HasTotal (Data.Functor.Contravariant.Predicate a)
instance Data.Set.Class.HasEmptyWith (a -> k) (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Set.Class.HasEmptyWith (Data.Set.Internal.Set a) (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance (Data.Set.Class.HasUnion s, Data.Set.Class.HasEmpty s) => GHC.Base.Monoid (Data.Set.Class.Union 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.Set.Class.HasEmpty (Data.Set.Internal.Set a)
instance Data.Set.Class.HasEmpty (Data.Map.Internal.Map k a)
instance Data.Set.Class.HasEmpty [a]
instance Data.Set.Class.HasEmpty (Data.Vector.Vector a)
instance Data.Set.Class.HasEmpty (Data.Sequence.Internal.Seq a)
instance Data.Set.Class.HasEmpty Data.IntSet.Internal.IntSet
instance Data.Set.Class.HasEmpty (Data.IntMap.Internal.IntMap a)
instance Data.Set.Class.HasEmpty (Data.HashSet.Base.HashSet a)
instance Data.Set.Class.HasEmpty (Data.HashMap.Base.HashMap k a)
instance Data.Set.Class.HasEmpty (Data.Functor.Contravariant.Predicate a)
instance Data.Set.Class.HasEmpty (Data.Set.Ordered.Many.OMSet a)
instance Data.Set.Class.HasEmpty (Data.Set.Unordered.Many.UMSet a)
instance Data.Set.Class.HasEmpty (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Ord k => Data.Set.Class.HasInsertWith k a (Data.Map.Internal.Map k a)
instance Data.Set.Class.HasInsertWith Data.IntSet.Internal.Key a (Data.IntMap.Internal.IntMap a)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Set.Class.HasInsertWith k a (Data.HashMap.Base.HashMap k a)
instance GHC.Classes.Ord a => Data.Set.Class.HasInsert a (Data.Set.Internal.Set a)
instance Data.Set.Class.HasInsert a [a]
instance Data.Set.Class.HasInsert a (Data.Vector.Vector a)
instance Data.Set.Class.HasInsert Data.IntSet.Internal.Key Data.IntSet.Internal.IntSet
instance (Data.Hashable.Class.Hashable a, GHC.Classes.Eq a) => Data.Set.Class.HasInsert a (Data.HashSet.Base.HashSet a)
instance GHC.Classes.Ord k => Data.Set.Class.HasInsert a (Data.Set.Ordered.Unique.With.SetWith k a)
instance GHC.Classes.Eq a => Data.Set.Class.HasInsert a (Data.Functor.Contravariant.Predicate a)
instance GHC.Classes.Ord a => Data.Set.Class.HasInsert a (Data.Set.Ordered.Many.OMSet a)
instance Data.Set.Class.HasInsert a (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasInsert a (Data.Set.Unordered.Unique.UUSet 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.Internal.Set a)
instance GHC.Classes.Ord k => Data.Set.Class.HasDelete k (Data.Map.Internal.Map k a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a [a]
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a (Data.Vector.Vector a)
instance Data.Set.Class.HasDelete Data.IntSet.Internal.Key Data.IntSet.Internal.IntSet
instance Data.Set.Class.HasDelete Data.IntSet.Internal.Key (Data.IntMap.Internal.IntMap a)
instance (Data.Hashable.Class.Hashable a, GHC.Classes.Eq a) => Data.Set.Class.HasDelete a (Data.HashSet.Base.HashSet a)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Set.Class.HasDelete k (Data.HashMap.Base.HashMap k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasDelete a (Data.Set.Ordered.Unique.With.SetWith k a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a (Data.Functor.Contravariant.Predicate a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDelete a (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasDelete a (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance Data.Set.Class.HasSingletonWith k a (Data.Map.Internal.Map k a)
instance Data.Set.Class.HasSingletonWith Data.IntSet.Internal.Key a (Data.IntMap.Internal.IntMap a)
instance Data.Hashable.Class.Hashable k => Data.Set.Class.HasSingletonWith k a (Data.HashMap.Base.HashMap k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasSingletonWith (a -> k) a (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Set.Class.HasSingletonWith (Data.Set.Internal.Set a) a (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance Data.Set.Class.HasSingleton a (Data.Set.Internal.Set a)
instance Data.Set.Class.HasSingleton a [a]
instance Data.Set.Class.HasSingleton a (Data.Vector.Vector a)
instance Data.Set.Class.HasSingleton a (Data.Sequence.Internal.Seq a)
instance Data.Set.Class.HasSingleton Data.IntSet.Internal.Key Data.IntSet.Internal.IntSet
instance Data.Hashable.Class.Hashable a => Data.Set.Class.HasSingleton a (Data.HashSet.Base.HashSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasSingleton a (Data.Functor.Contravariant.Predicate a)
instance Data.Set.Class.HasSingleton a (Data.Set.Ordered.Many.OMSet a)
instance Data.Set.Class.HasSingleton a (Data.Set.Unordered.Many.UMSet a)
instance Data.Set.Class.HasSingleton a (Data.Set.Unordered.Unique.UUSet a)
instance Data.Set.Class.HasComplement (Data.Functor.Contravariant.Predicate a)
instance GHC.Classes.Ord a => Data.Set.Class.HasComplement (Data.Set.Ordered.Unique.Finite.FiniteSet a)
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.HasUnion s, Data.Set.Class.HasIntersection s, Data.Set.Class.HasDifference s) => GHC.Base.Semigroup (Data.Set.Class.XUnion s)
instance (Data.Set.Class.HasUnion s, Data.Set.Class.HasIntersection s, Data.Set.Class.HasDifference s) => Data.Set.Class.HasXUnion s
instance GHC.Classes.Ord a => Data.Set.Class.HasDifference (Data.Set.Internal.Set a)
instance GHC.Classes.Ord k => Data.Set.Class.HasDifference (Data.Map.Internal.Map k a)
instance Data.Set.Class.HasDifference Data.IntSet.Internal.IntSet
instance Data.Set.Class.HasDifference (Data.IntMap.Internal.IntMap a)
instance (Data.Hashable.Class.Hashable a, GHC.Classes.Eq a) => Data.Set.Class.HasDifference (Data.HashSet.Base.HashSet a)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Set.Class.HasDifference (Data.HashMap.Base.HashMap k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasDifference (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Set.Class.HasDifference (Data.Functor.Contravariant.Predicate a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDifference (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDifference (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasDifference (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasDifference (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance Data.Set.Class.HasIntersection s => Data.Commutative.Commutative (Data.Set.Class.Intersection s)
instance Data.Set.Class.HasIntersection s => GHC.Base.Semigroup (Data.Set.Class.Intersection s)
instance GHC.Classes.Ord a => Data.Set.Class.HasIntersection (Data.Set.Internal.Set a)
instance GHC.Classes.Ord k => Data.Set.Class.HasIntersection (Data.Map.Internal.Map k a)
instance Data.Set.Class.HasIntersection Data.IntSet.Internal.IntSet
instance Data.Set.Class.HasIntersection (Data.IntMap.Internal.IntMap a)
instance (Data.Hashable.Class.Hashable a, GHC.Classes.Eq a) => Data.Set.Class.HasIntersection (Data.HashSet.Base.HashSet a)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Set.Class.HasIntersection (Data.HashMap.Base.HashMap k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasIntersection (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Set.Class.HasIntersection (Data.Functor.Contravariant.Predicate a)
instance GHC.Classes.Ord a => Data.Set.Class.HasIntersection (Data.Set.Ordered.Many.OMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasIntersection (Data.Set.Unordered.Many.UMSet a)
instance GHC.Classes.Eq a => Data.Set.Class.HasIntersection (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasIntersection (Data.Set.Ordered.Unique.Finite.FiniteSet a)
instance Data.Set.Class.HasUnion s => Data.Commutative.Commutative (Data.Set.Class.Union s)
instance Data.Set.Class.HasUnion s => GHC.Base.Semigroup (Data.Set.Class.Union s)
instance GHC.Classes.Ord a => Data.Set.Class.HasUnion (Data.Set.Internal.Set a)
instance GHC.Classes.Ord k => Data.Set.Class.HasUnion (Data.Map.Internal.Map k a)
instance Data.Set.Class.HasUnion Data.IntSet.Internal.IntSet
instance Data.Set.Class.HasUnion (Data.IntMap.Internal.IntMap a)
instance (Data.Hashable.Class.Hashable a, GHC.Classes.Eq a) => Data.Set.Class.HasUnion (Data.HashSet.Base.HashSet a)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Set.Class.HasUnion (Data.HashMap.Base.HashMap k a)
instance GHC.Classes.Ord k => Data.Set.Class.HasUnion (Data.Set.Ordered.Unique.With.SetWith k a)
instance Data.Set.Class.HasUnion (Data.Functor.Contravariant.Predicate a)
instance GHC.Classes.Ord a => Data.Set.Class.HasUnion (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.HasUnion (Data.Set.Unordered.Unique.UUSet a)
instance GHC.Classes.Ord a => Data.Set.Class.HasUnion (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 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)