Safe Haskell	None
Language	Haskell2010

Data.Set.Class

Contents

Union
Intersection
Per-Element
Top and Bottom Elements
- Size
Relation
Generic Builders

Description

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.

Synopsis

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 #
HasUnion (Predicate a) #
Methods union :: Predicate a -> Predicate a -> Predicate a #
(Hashable a, Eq a) => HasUnion (HashSet a) #
Methods union :: HashSet a -> HashSet a -> HashSet a #
Eq a => HasUnion (UUSet a) #
Methods union :: UUSet a -> UUSet a -> UUSet a #
Eq a => HasUnion (UMSet a) #
Methods union :: UMSet a -> UMSet a -> UMSet a #
Ord a => HasUnion (FiniteSet a) #
Methods union :: FiniteSet a -> FiniteSet a -> FiniteSet a #
Ord a => HasUnion (OMSet a) #
Methods union :: OMSet a -> OMSet a -> OMSet 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 #
(Hashable k, Eq k) => HasUnion (HashMap k a) #
Methods union :: HashMap k a -> HashMap k a -> HashMap k a #
Ord k => HasUnion (SetWith k a) #
Methods union :: SetWith k a -> SetWith k a -> SetWith 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 #
HasUnion s => Commutative (Union s) #
Methods commute :: Union s -> Union s -> Union s #
(Commutative (Union s), HasEmpty s) => CommutativeId (Union s) #
Methods cempty :: 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 #
HasIntersection (Predicate a) #
Methods intersection :: Predicate a -> Predicate a -> Predicate a #
(Hashable a, Eq a) => HasIntersection (HashSet a) #
Methods intersection :: HashSet a -> HashSet a -> HashSet a #
Eq a => HasIntersection (UUSet a) #
Methods intersection :: UUSet a -> UUSet a -> UUSet a #
Eq a => HasIntersection (UMSet a) #
Methods intersection :: UMSet a -> UMSet a -> UMSet a #
Ord a => HasIntersection (FiniteSet a) #
Methods intersection :: FiniteSet a -> FiniteSet a -> FiniteSet a #
Ord a => HasIntersection (OMSet a) #
Methods intersection :: OMSet a -> OMSet a -> OMSet 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 #
(Hashable k, Eq k) => HasIntersection (HashMap k a) #
Methods intersection :: HashMap k a -> HashMap k a -> HashMap k a #
Ord k => HasIntersection (SetWith k a) #
Methods intersection :: SetWith k a -> SetWith k a -> SetWith 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 #
HasIntersection s => Commutative (Intersection s) #
Methods commute :: Intersection s -> Intersection s -> Intersection s #
(Commutative (Intersection s), HasTotal s) => CommutativeId (Intersection s) #
Methods cempty :: 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 #
HasDifference (Predicate a) #
Methods difference :: Predicate a -> Predicate a -> Predicate a #
(Hashable a, Eq a) => HasDifference (HashSet a) #
Methods difference :: HashSet a -> HashSet a -> HashSet a #
Eq a => HasDifference (UUSet a) #
Methods difference :: UUSet a -> UUSet a -> UUSet a #
Eq a => HasDifference (UMSet a) #
Methods difference :: UMSet a -> UMSet a -> UMSet a #
Ord a => HasDifference (FiniteSet a) #
Methods difference :: FiniteSet a -> FiniteSet a -> FiniteSet a #
Eq a => HasDifference (OMSet a) #
Methods difference :: OMSet a -> OMSet a -> OMSet 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 #
(Hashable k, Eq k) => HasDifference (HashMap k a) #
Methods difference :: HashMap k a -> HashMap k a -> HashMap k a #
Ord k => HasDifference (SetWith k a) #
Methods difference :: SetWith k a -> SetWith k a -> SetWith 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

HasComplement (Predicate a) #
Methods complement :: Predicate a -> Predicate a #
Ord a => HasComplement (FiniteSet a) #
Methods complement :: FiniteSet a -> FiniteSet 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 (IntMap a) #
Methods empty :: IntMap a #
HasEmpty (Seq a) #
Methods empty :: Seq a #
HasEmpty (Set a) #
Methods empty :: Set a #
HasEmpty (Predicate a) #
Methods empty :: Predicate a #
HasEmpty (HashSet a) #
Methods empty :: HashSet a #
HasEmpty (UUSet a) #
Methods empty :: UUSet a #
HasEmpty (UMSet a) #
Methods empty :: UMSet a #
HasEmpty (OMSet a) #
Methods empty :: OMSet 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 (IntMap a) #
Methods size :: IntMap a -> Int #
HasSize (Seq a) #
Methods size :: Seq a -> Int #
HasSize (Set a) #
Methods size :: Set a -> Int #
HasSize (HashSet a) #
Methods size :: HashSet a -> Int #
HasSize (UUSet a) #
Methods size :: UUSet a -> Int #
HasSize (UMSet a) #
Methods size :: UMSet a -> Int #
HasSize (FiniteSet a) #
Methods size :: FiniteSet a -> Int #
HasSize (OMSet a) #
Methods size :: OMSet 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 (HashMap k a) #
Methods size :: HashMap k a -> Int #
HasSize (SetWith k a) #
Methods size :: SetWith 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 (UUSet a) #
Methods isSubsetOf :: UUSet a -> UUSet a -> Bool #
Eq a => CanBeSubset (UMSet a) #
Methods isSubsetOf :: UMSet a -> UMSet a -> Bool #
Ord a => CanBeSubset (FiniteSet a) #
Methods isSubsetOf :: FiniteSet a -> FiniteSet a -> Bool #
Eq a => CanBeSubset (OMSet a) #
Methods isSubsetOf :: OMSet a -> OMSet 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 (UUSet a) #
Methods isProperSubsetOf :: UUSet a -> UUSet a -> Bool #
Eq a => CanBeProperSubset (UMSet a) #
Methods isProperSubsetOf :: UMSet a -> UMSet a -> Bool #
Ord a => CanBeProperSubset (FiniteSet a) #
Methods isProperSubsetOf :: FiniteSet a -> FiniteSet a -> Bool #
Eq a => CanBeProperSubset (OMSet a) #
Methods isProperSubsetOf :: OMSet a -> OMSet 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 #