Data.Set.Class

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.

Union

class HasUnion s where

Minimal complete definition

union

Methods

union :: s -> s -> s

Instances

HasUnion IntSet

Methods

union :: IntSet -> IntSet -> IntSet

HasUnion (IntMap a)

Methods

union :: IntMap a -> IntMap a -> IntMap a

Ord a => HasUnion (Set a)

Methods

union :: Set a -> Set a -> Set a

Ord a => HasUnion (OMSet a)

Methods

union :: OMSet a -> OMSet a -> OMSet a

Ord a => HasUnion (FiniteSet a)

Methods

union :: FiniteSet a -> FiniteSet a -> FiniteSet a

Eq a => HasUnion (UMSet a)

Methods

union :: UMSet a -> UMSet a -> UMSet a

Eq a => HasUnion (UUSet a)

Methods

union :: UUSet a -> UUSet a -> UUSet a

(Hashable a, Eq a) => HasUnion (HashSet a)

Methods

union :: HashSet a -> HashSet a -> HashSet a

HasUnion (Predicate a)

Methods

union :: Predicate a -> Predicate a -> Predicate a

HasUnion a => HasUnion (XUnion a)

Methods

union :: XUnion a -> XUnion a -> XUnion a

HasUnion a => HasUnion (Intersection a)

Methods

union :: Intersection a -> Intersection a -> Intersection a

HasUnion a => HasUnion (Union a)

Methods

union :: Union a -> Union a -> Union a

Ord k => HasUnion (Map k a)

Methods

union :: Map k a -> Map k a -> Map k a

Ord k => HasUnion (SetWith k a)

Methods

union :: SetWith k a -> SetWith k a -> SetWith k a

(Hashable k, Eq k) => HasUnion (HashMap k a)

Methods

union :: HashMap k a -> HashMap k a -> HashMap k a

(Ord k, HasUnion (c a)) => HasUnion (SetsWith k c a)

Methods

union :: SetsWith k c a -> SetsWith k c a -> SetsWith k c a

unions :: (Foldable f, Monoid (Union s)) => f s -> s

unions1 :: (Foldable1 f, Semigroup (Union s)) => f s -> s

newtype Union a

Constructors

Union

Fields

• unUnion :: a

Instances

Functor Union

Methods

fmap :: (a -> b) -> Union a -> Union b

(<$) :: a -> Union b -> Union a

Foldable Union

Methods

fold :: Monoid m => Union m -> m

foldMap :: Monoid m => (a -> m) -> Union a -> m

foldr :: (a -> b -> b) -> b -> Union a -> b

foldr' :: (a -> b -> b) -> b -> Union a -> b

foldl :: (b -> a -> b) -> b -> Union a -> b

foldl' :: (b -> a -> b) -> b -> Union a -> b

foldr1 :: (a -> a -> a) -> Union a -> a

foldl1 :: (a -> a -> a) -> Union a -> a

toList :: Union a -> [a]

null :: Union a -> Bool

length :: Union a -> Int

elem :: Eq a => a -> Union a -> Bool

maximum :: Ord a => Union a -> a

minimum :: Ord a => Union a -> a

sum :: Num a => Union a -> a

product :: Num a => Union a -> a

Traversable Union

Methods

traverse :: Applicative f => (a -> f b) -> Union a -> f (Union b)

sequenceA :: Applicative f => Union (f a) -> f (Union a)

mapM :: Monad m => (a -> m b) -> Union a -> m (Union b)

sequence :: Monad m => Union (m a) -> m (Union a)

HasInsertWith k x a => HasInsertWith k x (Union a)

Methods

insertWith :: k -> x -> Union a -> Union a

HasSingletonWith k x a => HasSingletonWith k x (Union a)

Methods

singletonWith :: k -> x -> Union a

HasTotalWith k a => HasTotalWith k (Union a)

Methods

totalWith :: k -> Union a

HasEmptyWith k a => HasEmptyWith k (Union a)

Methods

emptyWith :: k -> Union a

HasInsert x a => HasInsert x (Union a)

Methods

insert :: x -> Union a -> Union a

HasDelete x a => HasDelete x (Union a)

Methods

delete :: x -> Union a -> Union a

HasSingleton x a => HasSingleton x (Union a)

Methods

singleton :: x -> Union a

Eq a => Eq (Union a)

Methods

(==) :: Union a -> Union a -> Bool

(/=) :: Union a -> Union a -> Bool

Ord a => Ord (Union a)

Methods

compare :: Union a -> Union a -> Ordering

(<) :: Union a -> Union a -> Bool

(<=) :: Union a -> Union a -> Bool

(>) :: Union a -> Union a -> Bool

(>=) :: Union a -> Union a -> Bool

max :: Union a -> Union a -> Union a

min :: Union a -> Union a -> Union a

Show a => Show (Union a)

Methods

showsPrec :: Int -> Union a -> ShowS

show :: Union a -> String

showList :: [Union a] -> ShowS

HasUnion s => Semigroup (Union s)

Methods

(<>) :: Union s -> Union s -> Union s

sconcat :: NonEmpty (Union s) -> Union s

stimes :: Integral b => b -> Union s -> Union s

(HasUnion s, HasEmpty s) => Monoid (Union s)

Methods

mempty :: Union s

mappend :: Union s -> Union s -> Union s

mconcat :: [Union s] -> Union s

(Commutative (Union s), HasEmpty s) => CommutativeId (Union s)

Methods

cempty :: Union s

HasUnion s => Commutative (Union s)

Methods

commute :: Union s -> Union s -> Union s

CanBeProperSubset a => CanBeProperSubset (Union a)

Methods

isProperSubsetOf :: Union a -> Union a -> Bool

CanBeSubset a => CanBeSubset (Union a)

Methods

isSubsetOf :: Union a -> Union a -> Bool

HasSize a => HasSize (Union a)

Methods

size :: Union a -> Int

HasTotal a => HasTotal (Union a)

Methods

total :: Union a

HasEmpty a => HasEmpty (Union a)

Methods

empty :: Union a

HasComplement a => HasComplement (Union a)

Methods

complement :: Union a -> Union a

HasDifference a => HasDifference (Union a)

Methods

difference :: Union a -> Union a -> Union a

HasIntersection a => HasIntersection (Union a)

Methods

intersection :: Union a -> Union a -> Union a

HasUnion a => HasUnion (Union a)

Methods

union :: Union a -> Union a -> Union a

Intersection

class HasIntersection s where

Minimal complete definition

intersection

Methods

intersection :: s -> s -> s

Instances

HasIntersection IntSet

Methods

intersection :: IntSet -> IntSet -> IntSet

HasIntersection (IntMap a)

Methods

intersection :: IntMap a -> IntMap a -> IntMap a

Ord a => HasIntersection (Set a)

Methods

intersection :: Set a -> Set a -> Set a

Ord a => HasIntersection (OMSet a)

Methods

intersection :: OMSet a -> OMSet a -> OMSet a

Ord a => HasIntersection (FiniteSet a)

Methods

intersection :: FiniteSet a -> FiniteSet a -> FiniteSet a

Eq a => HasIntersection (UMSet a)

Methods

intersection :: UMSet a -> UMSet a -> UMSet a

Eq a => HasIntersection (UUSet a)

Methods

intersection :: UUSet a -> UUSet a -> UUSet a

(Hashable a, Eq a) => HasIntersection (HashSet a)

Methods

intersection :: HashSet a -> HashSet a -> HashSet a

HasIntersection (Predicate a)

Methods

intersection :: Predicate a -> Predicate a -> Predicate a

HasIntersection a => HasIntersection (XUnion a)

Methods

intersection :: XUnion a -> XUnion a -> XUnion a

HasIntersection a => HasIntersection (Intersection a)

Methods

intersection :: Intersection a -> Intersection a -> Intersection a

HasIntersection a => HasIntersection (Union a)

Methods

intersection :: Union a -> Union a -> Union a

Ord k => HasIntersection (Map k a)

Methods

intersection :: Map k a -> Map k a -> Map k a

Ord k => HasIntersection (SetWith k a)

Methods

intersection :: SetWith k a -> SetWith k a -> SetWith k a

(Hashable k, Eq k) => HasIntersection (HashMap k a)

Methods

intersection :: HashMap k a -> HashMap k a -> HashMap k a

(Ord k, Eq (c a), HasEmpty (c a), HasIntersection (c a)) => HasIntersection (SetsWith k c a)

Methods

intersection :: SetsWith k c a -> SetsWith k c a -> SetsWith k c a

intersections :: (Foldable f, Monoid (Intersection s)) => f s -> s

intersections1 :: (Foldable1 f, Semigroup (Intersection s)) => f s -> s

newtype Intersection a

Constructors

Intersection

Fields

• unIntersection :: a

Instances

Functor Intersection

Methods

fmap :: (a -> b) -> Intersection a -> Intersection b

(<$) :: a -> Intersection b -> Intersection a

Foldable Intersection

Methods

fold :: Monoid m => Intersection m -> m

foldMap :: Monoid m => (a -> m) -> Intersection a -> m

foldr :: (a -> b -> b) -> b -> Intersection a -> b

foldr' :: (a -> b -> b) -> b -> Intersection a -> b

foldl :: (b -> a -> b) -> b -> Intersection a -> b

foldl' :: (b -> a -> b) -> b -> Intersection a -> b

foldr1 :: (a -> a -> a) -> Intersection a -> a

foldl1 :: (a -> a -> a) -> Intersection a -> a

toList :: Intersection a -> [a]

null :: Intersection a -> Bool

length :: Intersection a -> Int

elem :: Eq a => a -> Intersection a -> Bool

maximum :: Ord a => Intersection a -> a

minimum :: Ord a => Intersection a -> a

sum :: Num a => Intersection a -> a

product :: Num a => Intersection a -> a

Traversable Intersection

Methods

traverse :: Applicative f => (a -> f b) -> Intersection a -> f (Intersection b)

sequenceA :: Applicative f => Intersection (f a) -> f (Intersection a)

mapM :: Monad m => (a -> m b) -> Intersection a -> m (Intersection b)

sequence :: Monad m => Intersection (m a) -> m (Intersection a)

HasInsertWith k x a => HasInsertWith k x (Intersection a)

Methods

insertWith :: k -> x -> Intersection a -> Intersection a

HasSingletonWith k x a => HasSingletonWith k x (Intersection a)

Methods

singletonWith :: k -> x -> Intersection a

HasTotalWith k a => HasTotalWith k (Intersection a)

Methods

totalWith :: k -> Intersection a

HasEmptyWith k a => HasEmptyWith k (Intersection a)

Methods

emptyWith :: k -> Intersection a

HasInsert x a => HasInsert x (Intersection a)

Methods

insert :: x -> Intersection a -> Intersection a

HasDelete x a => HasDelete x (Intersection a)

Methods

delete :: x -> Intersection a -> Intersection a

HasSingleton x a => HasSingleton x (Intersection a)

Methods

singleton :: x -> Intersection a

Eq a => Eq (Intersection a)

Methods

(==) :: Intersection a -> Intersection a -> Bool

(/=) :: Intersection a -> Intersection a -> Bool

Ord a => Ord (Intersection a)

Methods

compare :: Intersection a -> Intersection a -> Ordering

(<) :: Intersection a -> Intersection a -> Bool

(<=) :: Intersection a -> Intersection a -> Bool

(>) :: Intersection a -> Intersection a -> Bool

(>=) :: Intersection a -> Intersection a -> Bool

max :: Intersection a -> Intersection a -> Intersection a

min :: Intersection a -> Intersection a -> Intersection a

Show a => Show (Intersection a)

Methods

showsPrec :: Int -> Intersection a -> ShowS

show :: Intersection a -> String

showList :: [Intersection a] -> ShowS

HasIntersection s => Semigroup (Intersection s)

Methods

(<>) :: Intersection s -> Intersection s -> Intersection s

sconcat :: NonEmpty (Intersection s) -> Intersection s

stimes :: Integral b => b -> Intersection s -> Intersection s

(HasIntersection s, HasTotal s) => Monoid (Intersection s)

Methods

mempty :: Intersection s

mappend :: Intersection s -> Intersection s -> Intersection s

mconcat :: [Intersection s] -> Intersection s

(Commutative (Intersection s), HasTotal s) => CommutativeId (Intersection s)

Methods

cempty :: Intersection s

HasIntersection s => Commutative (Intersection s)

Methods

commute :: Intersection s -> Intersection s -> Intersection s

CanBeProperSubset a => CanBeProperSubset (Intersection a)

Methods

isProperSubsetOf :: Intersection a -> Intersection a -> Bool

CanBeSubset a => CanBeSubset (Intersection a)

Methods

isSubsetOf :: Intersection a -> Intersection a -> Bool

HasSize a => HasSize (Intersection a)

Methods

size :: Intersection a -> Int

HasTotal a => HasTotal (Intersection a)

Methods

total :: Intersection a

HasEmpty a => HasEmpty (Intersection a)

Methods

empty :: Intersection a

HasComplement a => HasComplement (Intersection a)

Methods

complement :: Intersection a -> Intersection a

HasDifference a => HasDifference (Intersection a)

Methods

difference :: Intersection a -> Intersection a -> Intersection a

HasIntersection a => HasIntersection (Intersection a)

Methods

intersection :: Intersection a -> Intersection a -> Intersection a

HasUnion a => HasUnion (Intersection a)

Methods

union :: Intersection a -> Intersection a -> Intersection a

Difference

class HasDifference s where

Minimal complete definition

difference

Methods

difference :: s -> s -> s

Instances

HasDifference IntSet

Methods

difference :: IntSet -> IntSet -> IntSet

HasDifference (IntMap a)

Methods

difference :: IntMap a -> IntMap a -> IntMap a

Ord a => HasDifference (Set a)

Methods

difference :: Set a -> Set a -> Set a

Eq a => HasDifference (OMSet a)

Methods

difference :: OMSet a -> OMSet a -> OMSet a

Ord a => HasDifference (FiniteSet a)

Methods

difference :: FiniteSet a -> FiniteSet a -> FiniteSet a

Eq a => HasDifference (UMSet a)

Methods

difference :: UMSet a -> UMSet a -> UMSet a

Eq a => HasDifference (UUSet a)

Methods

difference :: UUSet a -> UUSet a -> UUSet a

(Hashable a, Eq a) => HasDifference (HashSet a)

Methods

difference :: HashSet a -> HashSet a -> HashSet a

HasDifference (Predicate a)

Methods

difference :: Predicate a -> Predicate a -> Predicate a

HasDifference a => HasDifference (XUnion a)

Methods

difference :: XUnion a -> XUnion a -> XUnion a

HasDifference a => HasDifference (Intersection a)

Methods

difference :: Intersection a -> Intersection a -> Intersection a

HasDifference a => HasDifference (Union a)

Methods

difference :: Union a -> Union a -> Union a

Ord k => HasDifference (Map k a)

Methods

difference :: Map k a -> Map k a -> Map k a

Ord k => HasDifference (SetWith k a)

Methods

difference :: SetWith k a -> SetWith k a -> SetWith k a

(Hashable k, Eq k) => HasDifference (HashMap k a)

Methods

difference :: HashMap k a -> HashMap k a -> HashMap k a

(Ord k, Eq (c a), HasEmpty (c a), HasDifference (c a)) => HasDifference (SetsWith k c a)

Methods

difference :: SetsWith k c a -> SetsWith k c a -> SetsWith k c a

(\\) :: HasDifference s => s -> s -> s

Exclusive Union / Symmetric Difference

class HasXUnion s where

Minimal complete definition

xunion

Methods

xunion :: s -> s -> s

Instances

(HasUnion s, HasIntersection s, HasDifference s) => HasXUnion s

Methods

xunion :: s -> s -> s

xunions :: (Foldable f, Monoid (XUnion s)) => f s -> s

xunions1 :: (Foldable1 f, Semigroup (XUnion s)) => f s -> s

newtype XUnion a

Constructors

XUnion

Fields

• unXUnion :: a

Instances

Functor XUnion

Methods

fmap :: (a -> b) -> XUnion a -> XUnion b

(<$) :: a -> XUnion b -> XUnion a

Foldable XUnion

Methods

fold :: Monoid m => XUnion m -> m

foldMap :: Monoid m => (a -> m) -> XUnion a -> m

foldr :: (a -> b -> b) -> b -> XUnion a -> b

foldr' :: (a -> b -> b) -> b -> XUnion a -> b

foldl :: (b -> a -> b) -> b -> XUnion a -> b

foldl' :: (b -> a -> b) -> b -> XUnion a -> b

foldr1 :: (a -> a -> a) -> XUnion a -> a

foldl1 :: (a -> a -> a) -> XUnion a -> a

toList :: XUnion a -> [a]

null :: XUnion a -> Bool

length :: XUnion a -> Int

elem :: Eq a => a -> XUnion a -> Bool

maximum :: Ord a => XUnion a -> a

minimum :: Ord a => XUnion a -> a

sum :: Num a => XUnion a -> a

product :: Num a => XUnion a -> a

Traversable XUnion

Methods

traverse :: Applicative f => (a -> f b) -> XUnion a -> f (XUnion b)

sequenceA :: Applicative f => XUnion (f a) -> f (XUnion a)

mapM :: Monad m => (a -> m b) -> XUnion a -> m (XUnion b)

sequence :: Monad m => XUnion (m a) -> m (XUnion a)

HasInsertWith k x a => HasInsertWith k x (XUnion a)

Methods

insertWith :: k -> x -> XUnion a -> XUnion a

HasSingletonWith k x a => HasSingletonWith k x (XUnion a)

Methods

singletonWith :: k -> x -> XUnion a

HasTotalWith k a => HasTotalWith k (XUnion a)

Methods

totalWith :: k -> XUnion a

HasEmptyWith k a => HasEmptyWith k (XUnion a)

Methods

emptyWith :: k -> XUnion a

HasInsert x a => HasInsert x (XUnion a)

Methods

insert :: x -> XUnion a -> XUnion a

HasDelete x a => HasDelete x (XUnion a)

Methods

delete :: x -> XUnion a -> XUnion a

HasSingleton x a => HasSingleton x (XUnion a)

Methods

singleton :: x -> XUnion a

Eq a => Eq (XUnion a)

Methods

(==) :: XUnion a -> XUnion a -> Bool

(/=) :: XUnion a -> XUnion a -> Bool

Ord a => Ord (XUnion a)

Methods

compare :: XUnion a -> XUnion a -> Ordering

(<) :: XUnion a -> XUnion a -> Bool

(<=) :: XUnion a -> XUnion a -> Bool

(>) :: XUnion a -> XUnion a -> Bool

(>=) :: XUnion a -> XUnion a -> Bool

max :: XUnion a -> XUnion a -> XUnion a

min :: XUnion a -> XUnion a -> XUnion a

Show a => Show (XUnion a)

Methods

showsPrec :: Int -> XUnion a -> ShowS

show :: XUnion a -> String

showList :: [XUnion a] -> ShowS

(HasXUnion s, HasUnion s, HasIntersection s, HasDifference s) => Semigroup (XUnion s)

Methods

(<>) :: XUnion s -> XUnion s -> XUnion s

sconcat :: NonEmpty (XUnion s) -> XUnion s

stimes :: Integral b => b -> XUnion s -> XUnion s

(HasXUnion s, HasEmpty s, HasUnion s, HasIntersection s, HasDifference s) => Monoid (XUnion s)

Methods

mempty :: XUnion s

mappend :: XUnion s -> XUnion s -> XUnion s

mconcat :: [XUnion s] -> XUnion s

(HasXUnion s, HasUnion s, HasIntersection s, HasDifference s) => Commutative (XUnion s)

Methods

commute :: XUnion s -> XUnion s -> XUnion s

CanBeProperSubset a => CanBeProperSubset (XUnion a)

Methods

isProperSubsetOf :: XUnion a -> XUnion a -> Bool

CanBeSubset a => CanBeSubset (XUnion a)

Methods

isSubsetOf :: XUnion a -> XUnion a -> Bool

HasSize a => HasSize (XUnion a)

Methods

size :: XUnion a -> Int

HasTotal a => HasTotal (XUnion a)

Methods

total :: XUnion a

HasEmpty a => HasEmpty (XUnion a)

Methods

empty :: XUnion a

HasComplement a => HasComplement (XUnion a)

Methods

complement :: XUnion a -> XUnion a

HasDifference a => HasDifference (XUnion a)

Methods

difference :: XUnion a -> XUnion a -> XUnion a

HasIntersection a => HasIntersection (XUnion a)

Methods

intersection :: XUnion a -> XUnion a -> XUnion a

HasUnion a => HasUnion (XUnion a)

Methods

union :: XUnion a -> XUnion a -> XUnion a

Complement

class HasComplement s where

Minimal complete definition

complement

Methods

complement :: s -> s

Instances

Ord a => HasComplement (FiniteSet a)

Methods

complement :: FiniteSet a -> FiniteSet a

HasComplement (Predicate a)

Methods

complement :: Predicate a -> Predicate a

HasComplement a => HasComplement (XUnion a)

Methods

complement :: XUnion a -> XUnion a

HasComplement a => HasComplement (Intersection a)

Methods

complement :: Intersection a -> Intersection a

HasComplement a => HasComplement (Union a)

Methods

complement :: Union a -> Union a

Per-Element

class HasSingleton a s where

Minimal complete definition

singleton

Methods

singleton :: a -> s

Instances

HasSingleton Key IntSet

Methods

singleton :: Key -> IntSet

HasSingleton a (UUSet a)

Methods

singleton :: a -> UUSet a

HasSingleton a (UMSet a)

Methods

singleton :: a -> UMSet a

HasSingleton a (OMSet a)

Methods

singleton :: a -> OMSet a

Eq a => HasSingleton a (Predicate a)

Methods

singleton :: a -> Predicate a

Hashable a => HasSingleton a (HashSet a)

Methods

singleton :: a -> HashSet a

HasSingleton a (Seq a)

Methods

singleton :: a -> Seq a

HasSingleton a [a]

Methods

singleton :: a -> [a]

HasSingleton a (Set a)

Methods

singleton :: a -> Set a

HasSingleton x a => HasSingleton x (XUnion a)

Methods

singleton :: x -> XUnion a

HasSingleton x a => HasSingleton x (Intersection a)

Methods

singleton :: x -> Intersection a

HasSingleton x a => HasSingleton x (Union a)

Methods

singleton :: x -> Union a

class HasSingletonWith k a s where

Minimal complete definition

singletonWith

Methods

singletonWith :: k -> a -> s

Instances

HasSingletonWith k x a => HasSingletonWith k x (XUnion a)

Methods

singletonWith :: k -> x -> XUnion a

HasSingletonWith k x a => HasSingletonWith k x (Intersection a)

Methods

singletonWith :: k -> x -> Intersection a

HasSingletonWith k x a => HasSingletonWith k x (Union a)

Methods

singletonWith :: k -> x -> Union a

HasSingletonWith Key a (IntMap a)

Methods

singletonWith :: Key -> a -> IntMap a

Hashable k => HasSingletonWith k a (HashMap k a)

Methods

singletonWith :: k -> a -> HashMap k a

HasSingletonWith k a (Map k a)

Methods

singletonWith :: k -> a -> Map k a

HasSingletonWith (Set a) a (FiniteSet a)

Methods

singletonWith :: Set a -> a -> FiniteSet a

Ord k => HasSingletonWith (a -> k) a (SetWith k a)

Methods

singletonWith :: (a -> k) -> a -> SetWith k a

(Ord k, HasUnion (c a), HasSingleton a (c a)) => HasSingletonWith (a -> k) a (SetsWith k c a)

Methods

singletonWith :: (a -> k) -> a -> SetsWith k c a

class HasDelete a s where

Minimal complete definition

delete

Methods

delete :: a -> s -> s

Instances

HasDelete Key IntSet

Methods

delete :: Key -> IntSet -> IntSet

Ord a => HasDelete a (FiniteSet a)

Methods

delete :: a -> FiniteSet a -> FiniteSet a

Eq a => HasDelete a (UUSet a)

Methods

delete :: a -> UUSet a -> UUSet a

Eq a => HasDelete a (UMSet a)

Methods

delete :: a -> UMSet a -> UMSet a

Eq a => HasDelete a (OMSet a)

Methods

delete :: a -> OMSet a -> OMSet a

Eq a => HasDelete a (Predicate a)

Methods

delete :: a -> Predicate a -> Predicate a

(Hashable a, Eq a) => HasDelete a (HashSet a)

Methods

delete :: a -> HashSet a -> HashSet a

Eq a => HasDelete a [a]

Methods

delete :: a -> [a] -> [a]

Ord a => HasDelete a (Set a)

Methods

delete :: a -> Set a -> Set a

HasDelete x a => HasDelete x (XUnion a)

Methods

delete :: x -> XUnion a -> XUnion a

HasDelete x a => HasDelete x (Intersection a)

Methods

delete :: x -> Intersection a -> Intersection a

HasDelete x a => HasDelete x (Union a)

Methods

delete :: x -> Union a -> Union a

HasDelete Key (IntMap a)

Methods

delete :: Key -> IntMap a -> IntMap a

Ord k => HasDelete a (SetWith k a)

Methods

delete :: a -> SetWith k a -> SetWith k a

(Hashable k, Eq k) => HasDelete k (HashMap k a)

Methods

delete :: k -> HashMap k a -> HashMap k a

Ord k => HasDelete k (Map k a)

Methods

delete :: k -> Map k a -> Map k a

(Ord k, Eq (c a), HasEmpty (c a), HasDelete a (c a)) => HasDelete a (SetsWith k c a)

Methods

delete :: a -> SetsWith k c a -> SetsWith k c a

class HasInsert a s where

Minimal complete definition

insert

Methods

insert :: a -> s -> s

Instances

HasInsert Key IntSet

Methods

insert :: Key -> IntSet -> IntSet

Ord a => HasInsert a (FiniteSet a)

Methods

insert :: a -> FiniteSet a -> FiniteSet a

Eq a => HasInsert a (UUSet a)

Methods

insert :: a -> UUSet a -> UUSet a

HasInsert a (UMSet a)

Methods

insert :: a -> UMSet a -> UMSet a

Ord a => HasInsert a (OMSet a)

Methods

insert :: a -> OMSet a -> OMSet a

Eq a => HasInsert a (Predicate a)

Methods

insert :: a -> Predicate a -> Predicate a

(Hashable a, Eq a) => HasInsert a (HashSet a)

Methods

insert :: a -> HashSet a -> HashSet a

HasInsert a [a]

Methods

insert :: a -> [a] -> [a]

Ord a => HasInsert a (Set a)

Methods

insert :: a -> Set a -> Set a

HasInsert x a => HasInsert x (XUnion a)

Methods

insert :: x -> XUnion a -> XUnion a

HasInsert x a => HasInsert x (Intersection a)

Methods

insert :: x -> Intersection a -> Intersection a

HasInsert x a => HasInsert x (Union a)

Methods

insert :: x -> Union a -> Union a

Ord k => HasInsert a (SetWith k a)

Methods

insert :: a -> SetWith k a -> SetWith k a

(Ord k, HasUnion (c a), HasSingleton a (c a)) => HasInsert a (SetsWith k c a)

Methods

insert :: a -> SetsWith k c a -> SetsWith k c a

class HasInsertWith k a s where

Minimal complete definition

insertWith

Methods

insertWith :: k -> a -> s -> s

Instances

HasInsertWith k x a => HasInsertWith k x (XUnion a)

Methods

insertWith :: k -> x -> XUnion a -> XUnion a

HasInsertWith k x a => HasInsertWith k x (Intersection a)

Methods

insertWith :: k -> x -> Intersection a -> Intersection a

HasInsertWith k x a => HasInsertWith k x (Union a)

Methods

insertWith :: k -> x -> Union a -> Union a

HasInsertWith Key a (IntMap a)

Methods

insertWith :: Key -> a -> IntMap a -> IntMap a

(Hashable k, Eq k) => HasInsertWith k a (HashMap k a)

Methods

insertWith :: k -> a -> HashMap k a -> HashMap k a

Ord k => HasInsertWith k a (Map k a)

Methods

insertWith :: k -> a -> Map k a -> Map k a

Top and Bottom Elements

class HasEmpty s where

Minimal complete definition

empty

Methods

empty :: s

Instances

HasEmpty IntSet

Methods

empty :: IntSet

HasEmpty [a]

Methods

empty :: [a]

HasEmpty (Seq a)

Methods

empty :: Seq a

HasEmpty (IntMap a)

Methods

empty :: IntMap a

HasEmpty (Set a)

Methods

empty :: Set a

HasEmpty (OMSet a)

Methods

empty :: OMSet a

HasEmpty (UMSet a)

Methods

empty :: UMSet a

HasEmpty (UUSet a)

Methods

empty :: UUSet a

HasEmpty (HashSet a)

Methods

empty :: HashSet a

HasEmpty (Predicate a)

Methods

empty :: Predicate a

HasEmpty a => HasEmpty (XUnion a)

Methods

empty :: XUnion a

HasEmpty a => HasEmpty (Intersection a)

Methods

empty :: Intersection a

HasEmpty a => HasEmpty (Union a)

Methods

empty :: Union a

HasEmpty (Map k a)

Methods

empty :: Map k a

HasEmpty (HashMap k a)

Methods

empty :: HashMap k a

class HasEmptyWith k s where

Minimal complete definition

emptyWith

Methods

emptyWith :: k -> s

Instances

HasEmptyWith k a => HasEmptyWith k (XUnion a)

Methods

emptyWith :: k -> XUnion a

HasEmptyWith k a => HasEmptyWith k (Intersection a)

Methods

emptyWith :: k -> Intersection a

HasEmptyWith k a => HasEmptyWith k (Union a)

Methods

emptyWith :: k -> Union a

HasEmptyWith (Set a) (FiniteSet a)

Methods

emptyWith :: Set a -> FiniteSet a

HasEmptyWith (a -> k) (SetWith k a)

Methods

emptyWith :: (a -> k) -> SetWith k a

HasEmptyWith (a -> k) (SetsWith k c a)

Methods

emptyWith :: (a -> k) -> SetsWith k c a

class HasTotal s where

Minimal complete definition

total

Methods

total :: s

Instances

HasTotal (Predicate a)

Methods

total :: Predicate a

HasTotal a => HasTotal (XUnion a)

Methods

total :: XUnion a

HasTotal a => HasTotal (Intersection a)

Methods

total :: Intersection a

HasTotal a => HasTotal (Union a)

Methods

total :: Union a

class HasTotalWith k s where

Minimal complete definition

totalWith

Methods

totalWith :: k -> s

Instances

HasTotalWith k a => HasTotalWith k (XUnion a)

Methods

totalWith :: k -> XUnion a

HasTotalWith k a => HasTotalWith k (Intersection a)

Methods

totalWith :: k -> Intersection a

HasTotalWith k a => HasTotalWith k (Union a)

Methods

totalWith :: k -> Union a

HasTotalWith (FiniteSet a) (FiniteSet a)

Methods

totalWith :: FiniteSet a -> FiniteSet a

Size

class HasSize s where

Minimal complete definition

size

Methods

size :: s -> Int

Instances

HasSize IntSet

Methods

size :: IntSet -> Int

HasSize [a]

Methods

size :: [a] -> Int

HasSize (Seq a)

Methods

size :: Seq a -> Int

HasSize (IntMap a)

Methods

size :: IntMap a -> Int

HasSize (Set a)

Methods

size :: Set a -> Int

HasSize (OMSet a)

Methods

size :: OMSet a -> Int

HasSize (FiniteSet a)

Methods

size :: FiniteSet a -> Int

HasSize (UMSet a)

Methods

size :: UMSet a -> Int

HasSize (UUSet a)

Methods

size :: UUSet a -> Int

HasSize (HashSet a)

Methods

size :: HashSet a -> Int

HasSize a => HasSize (XUnion a)

Methods

size :: XUnion a -> Int

HasSize a => HasSize (Intersection a)

Methods

size :: Intersection a -> Int

HasSize a => HasSize (Union a)

Methods

size :: Union a -> Int

HasSize (Map k a)

Methods

size :: Map k a -> Int

HasSize (SetWith k a)

Methods

size :: SetWith k a -> Int

HasSize (HashMap k a)

Methods

size :: HashMap k a -> Int

HasSize (SetsWith k c a)

Methods

size :: SetsWith k c a -> Int

Relation

class CanBeSubset s where

Minimal complete definition

isSubsetOf

Methods

isSubsetOf :: s -> s -> Bool

Instances

CanBeSubset IntSet

Methods

isSubsetOf :: IntSet -> IntSet -> Bool

Eq a => CanBeSubset (IntMap a)

Methods

isSubsetOf :: IntMap a -> IntMap a -> Bool

Ord a => CanBeSubset (Set a)

Methods

isSubsetOf :: Set a -> Set a -> Bool

Eq a => CanBeSubset (OMSet a)

Methods

isSubsetOf :: OMSet a -> OMSet a -> Bool

Ord a => CanBeSubset (FiniteSet a)

Methods

isSubsetOf :: FiniteSet a -> FiniteSet a -> Bool

Eq a => CanBeSubset (UMSet a)

Methods

isSubsetOf :: UMSet a -> UMSet a -> Bool

Eq a => CanBeSubset (UUSet a)

Methods

isSubsetOf :: UUSet a -> UUSet a -> Bool

CanBeSubset a => CanBeSubset (XUnion a)

Methods

isSubsetOf :: XUnion a -> XUnion a -> Bool

CanBeSubset a => CanBeSubset (Intersection a)

Methods

isSubsetOf :: Intersection a -> Intersection a -> Bool

CanBeSubset a => CanBeSubset (Union a)

Methods

isSubsetOf :: Union a -> Union a -> Bool

(Eq k, Ord k, Eq a) => CanBeSubset (Map k a)

Methods

isSubsetOf :: Map k a -> Map k a -> Bool

(Ord k, Eq a) => CanBeSubset (SetWith k a)

Methods

isSubsetOf :: SetWith k a -> SetWith k a -> Bool

(Ord k, Eq (c a), CanBeSubset (c a)) => CanBeSubset (SetsWith k c a)

Methods

isSubsetOf :: SetsWith k c a -> SetsWith k c a -> Bool

class CanBeProperSubset s where

Minimal complete definition

isProperSubsetOf

Methods

isProperSubsetOf :: s -> s -> Bool

Instances

CanBeProperSubset IntSet

Methods

isProperSubsetOf :: IntSet -> IntSet -> Bool

Eq a => CanBeProperSubset (IntMap a)

Methods

isProperSubsetOf :: IntMap a -> IntMap a -> Bool

Ord a => CanBeProperSubset (Set a)

Methods

isProperSubsetOf :: Set a -> Set a -> Bool

Eq a => CanBeProperSubset (OMSet a)

Methods

isProperSubsetOf :: OMSet a -> OMSet a -> Bool

Ord a => CanBeProperSubset (FiniteSet a)

Methods

isProperSubsetOf :: FiniteSet a -> FiniteSet a -> Bool

Eq a => CanBeProperSubset (UMSet a)

Methods

isProperSubsetOf :: UMSet a -> UMSet a -> Bool

Eq a => CanBeProperSubset (UUSet a)

Methods

isProperSubsetOf :: UUSet a -> UUSet a -> Bool

CanBeProperSubset a => CanBeProperSubset (XUnion a)

Methods

isProperSubsetOf :: XUnion a -> XUnion a -> Bool

CanBeProperSubset a => CanBeProperSubset (Intersection a)

Methods

isProperSubsetOf :: Intersection a -> Intersection a -> Bool

CanBeProperSubset a => CanBeProperSubset (Union a)

Methods

isProperSubsetOf :: Union a -> Union a -> Bool

(Eq k, Ord k, Eq a) => CanBeProperSubset (Map k a)

Methods

isProperSubsetOf :: Map k a -> Map k a -> Bool

(Ord k, Eq a) => CanBeProperSubset (SetWith k a)

Methods

isProperSubsetOf :: SetWith k a -> SetWith k a -> Bool

(Ord k, Eq (c a), CanBeSubset (c a)) => CanBeProperSubset (SetsWith k c a)

Methods

isProperSubsetOf :: SetsWith k c a -> SetsWith k c a -> Bool

Generic Builders

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