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


-- | Ducktyped set interface for Haskell containers.
--   
--   Includes overloaded functions for common set operations. See
--   <tt>Data.Set.Class</tt>.
@package sets
@version 0.0.5.1

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(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 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
instance Control.Monad.Base.MonadBase Test.QuickCheck.Gen.Gen Test.QuickCheck.Gen.Gen
instance (Test.QuickCheck.Arbitrary.Arbitrary a, GHC.Classes.Ord a) => Test.QuickCheck.Arbitrary.Arbitrary (Data.Set.Ordered.Many.OMSet a)

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

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

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


-- | 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 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.HasUnion s => Data.Semigroup.Semigroup (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.HasIntersection s => Data.Semigroup.Semigroup (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.Set.Class.HasXUnion s, Data.Set.Class.HasUnion s, Data.Set.Class.HasIntersection s, Data.Set.Class.HasDifference s) => Data.Semigroup.Semigroup (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 GHC.Classes.Ord 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 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)