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

Methods

union :: s -> s -> s

Instances

HasUnion IntSet

HasUnion (IntMap a)

Ord a => HasUnion (Set a)

HasUnion (Predicate a)

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

Ord a => HasUnion (FiniteSet a)

Eq a => HasUnion (UUSet a)

Eq a => HasUnion (UMSet a)

Ord a => HasUnion (OMSet a)

HasUnion a => HasUnion (XUnion a)

HasUnion a => HasUnion (Intersection a)

HasUnion a => HasUnion (Union a)

Ord k => HasUnion (Map k a)

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

Ord k => HasUnion (SetWith k a)

(Ord k, HasUnion (c a)) => HasUnion (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

Foldable Union

Traversable Union

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

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

HasTotalWith k a => HasTotalWith k (Union a)

HasEmptyWith k a => HasEmptyWith k (Union a)

HasInsert x a => HasInsert x (Union a)

HasDelete x a => HasDelete x (Union a)

HasSingleton x a => HasSingleton x (Union a)

Eq a => Eq (Union a)

Ord a => Ord (Union a)

Show a => Show (Union a)

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

HasUnion s => Semigroup (Union s)

HasUnion s => Commutative (Union s)

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

CanBeProperSubset a => CanBeProperSubset (Union a)

CanBeSubset a => CanBeSubset (Union a)

HasSize a => HasSize (Union a)

HasTotal a => HasTotal (Union a)

HasEmpty a => HasEmpty (Union a)

HasComplement a => HasComplement (Union a)

HasDifference a => HasDifference (Union a)

HasIntersection a => HasIntersection (Union a)

HasUnion a => HasUnion (Union a)

Intersection

class HasIntersection s where

Methods

intersection :: s -> s -> s

Instances

HasIntersection IntSet

HasIntersection (IntMap a)

Ord a => HasIntersection (Set a)

HasIntersection (Predicate a)

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

Ord a => HasIntersection (FiniteSet a)

Eq a => HasIntersection (UUSet a)

Eq a => HasIntersection (UMSet a)

Ord a => HasIntersection (OMSet a)

HasIntersection a => HasIntersection (XUnion a)

HasIntersection a => HasIntersection (Intersection a)

HasIntersection a => HasIntersection (Union a)

Ord k => HasIntersection (Map k a)

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

Ord k => HasIntersection (SetWith k a)

(Ord k, Eq (c a), HasEmpty (c a), HasIntersection (c a)) => HasIntersection (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

Foldable Intersection

Traversable Intersection

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

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

HasTotalWith k a => HasTotalWith k (Intersection a)

HasEmptyWith k a => HasEmptyWith k (Intersection a)

HasInsert x a => HasInsert x (Intersection a)

HasDelete x a => HasDelete x (Intersection a)

HasSingleton x a => HasSingleton x (Intersection a)

Eq a => Eq (Intersection a)

Ord a => Ord (Intersection a)

Show a => Show (Intersection a)

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

HasIntersection s => Semigroup (Intersection s)

HasIntersection s => Commutative (Intersection s)

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

CanBeProperSubset a => CanBeProperSubset (Intersection a)

CanBeSubset a => CanBeSubset (Intersection a)

HasSize a => HasSize (Intersection a)

HasTotal a => HasTotal (Intersection a)

HasEmpty a => HasEmpty (Intersection a)

HasComplement a => HasComplement (Intersection a)

HasDifference a => HasDifference (Intersection a)

HasIntersection a => HasIntersection (Intersection a)

HasUnion a => HasUnion (Intersection a)

Difference

class HasDifference s where

Methods

difference :: s -> s -> s

Instances

HasDifference IntSet

HasDifference (IntMap a)

Ord a => HasDifference (Set a)

HasDifference (Predicate a)

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

Ord a => HasDifference (FiniteSet a)

Eq a => HasDifference (UUSet a)

Eq a => HasDifference (UMSet a)

Eq a => HasDifference (OMSet a)

HasDifference a => HasDifference (XUnion a)

HasDifference a => HasDifference (Intersection a)

HasDifference a => HasDifference (Union a)

Ord k => HasDifference (Map k a)

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

Ord k => HasDifference (SetWith k a)

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

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

Exclusive Union / Symmetric Difference

class HasXUnion s where

Methods

xunion :: s -> s -> s

Instances

(HasUnion s, HasIntersection s, HasDifference s) => HasXUnion 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

Foldable XUnion

Traversable XUnion

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

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

HasTotalWith k a => HasTotalWith k (XUnion a)

HasEmptyWith k a => HasEmptyWith k (XUnion a)

HasInsert x a => HasInsert x (XUnion a)

HasDelete x a => HasDelete x (XUnion a)

HasSingleton x a => HasSingleton x (XUnion a)

Eq a => Eq (XUnion a)

Ord a => Ord (XUnion a)

Show a => Show (XUnion a)

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

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

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

CanBeProperSubset a => CanBeProperSubset (XUnion a)

CanBeSubset a => CanBeSubset (XUnion a)

HasSize a => HasSize (XUnion a)

HasTotal a => HasTotal (XUnion a)

HasEmpty a => HasEmpty (XUnion a)

HasComplement a => HasComplement (XUnion a)

HasDifference a => HasDifference (XUnion a)

HasIntersection a => HasIntersection (XUnion a)

HasUnion a => HasUnion (XUnion a)

Complement

class HasComplement s where

Methods

complement :: s -> s

Instances

HasComplement (Predicate a)

Ord a => HasComplement (FiniteSet a)

HasComplement a => HasComplement (XUnion a)

HasComplement a => HasComplement (Intersection a)

HasComplement a => HasComplement (Union a)

Per-Element

class HasSingleton a s where

Methods

singleton :: a -> s

Instances

HasSingleton Key IntSet

HasSingleton a (UUSet a)

HasSingleton a (UMSet a)

HasSingleton a (OMSet a)

Eq a => HasSingleton a (Predicate a)

Hashable a => HasSingleton a (HashSet a)

HasSingleton a (Seq a)

HasSingleton a [a]

HasSingleton a (Set a)

HasSingleton x a => HasSingleton x (XUnion a)

HasSingleton x a => HasSingleton x (Intersection a)

HasSingleton x a => HasSingleton x (Union a)

class HasSingletonWith k a s where

Methods

singletonWith :: k -> a -> s

Instances

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

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

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

HasSingletonWith Key a (IntMap a)

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

HasSingletonWith k a (Map k a)

HasSingletonWith (Set a) a (FiniteSet a)

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

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

class HasDelete a s where

Methods

delete :: a -> s -> s

Instances

HasDelete Key IntSet

Ord a => HasDelete a (FiniteSet a)

Eq a => HasDelete a (UUSet a)

Eq a => HasDelete a (UMSet a)

Eq a => HasDelete a (OMSet a)

Eq a => HasDelete a (Predicate a)

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

Eq a => HasDelete a [a]

Ord a => HasDelete a (Set a)

HasDelete x a => HasDelete x (XUnion a)

HasDelete x a => HasDelete x (Intersection a)

HasDelete x a => HasDelete x (Union a)

HasDelete Key (IntMap a)

Ord k => HasDelete a (SetWith k a)

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

Ord k => HasDelete k (Map k a)

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

class HasInsert a s where

Methods

insert :: a -> s -> s

Instances

HasInsert Key IntSet

Ord a => HasInsert a (FiniteSet a)

Eq a => HasInsert a (UUSet a)

HasInsert a (UMSet a)

Ord a => HasInsert a (OMSet a)

Eq a => HasInsert a (Predicate a)

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

HasInsert a [a]

Ord a => HasInsert a (Set a)

HasInsert x a => HasInsert x (XUnion a)

HasInsert x a => HasInsert x (Intersection a)

HasInsert x a => HasInsert x (Union a)

Ord k => HasInsert a (SetWith k a)

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

class HasInsertWith k a s where

Methods

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

Instances

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

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

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

HasInsertWith Key a (IntMap a)

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

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

Top and Bottom Elements

class HasEmpty s where

Methods

empty :: s

Instances

HasEmpty IntSet

HasEmpty [a]

HasEmpty (IntMap a)

HasEmpty (Set a)

HasEmpty (Seq a)

HasEmpty (Predicate a)

HasEmpty (HashSet a)

HasEmpty (UUSet a)

HasEmpty (UMSet a)

HasEmpty (OMSet a)

HasEmpty a => HasEmpty (XUnion a)

HasEmpty a => HasEmpty (Intersection a)

HasEmpty a => HasEmpty (Union a)

HasEmpty (Map k a)

HasEmpty (HashMap k a)

class HasEmptyWith k s where

Methods

emptyWith :: k -> s

Instances

HasEmptyWith k a => HasEmptyWith k (XUnion a)

HasEmptyWith k a => HasEmptyWith k (Intersection a)

HasEmptyWith k a => HasEmptyWith k (Union a)

HasEmptyWith (Set a) (FiniteSet a)

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

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

class HasTotal s where

Methods

total :: s

Instances

HasTotal (Predicate a)

HasTotal a => HasTotal (XUnion a)

HasTotal a => HasTotal (Intersection a)

HasTotal a => HasTotal (Union a)

class HasTotalWith k s where

Methods

totalWith :: k -> s

Instances

HasTotalWith k a => HasTotalWith k (XUnion a)

HasTotalWith k a => HasTotalWith k (Intersection a)

HasTotalWith k a => HasTotalWith k (Union a)

HasTotalWith (FiniteSet a) (FiniteSet a)

Size

class HasSize s where

Methods

size :: s -> Int

Instances

HasSize IntSet

HasSize [a]

HasSize (IntMap a)

HasSize (Set a)

HasSize (Seq a)

HasSize (HashSet a)

HasSize (FiniteSet a)

HasSize (UUSet a)

HasSize (UMSet a)

HasSize (OMSet a)

HasSize a => HasSize (XUnion a)

HasSize a => HasSize (Intersection a)

HasSize a => HasSize (Union a)

HasSize (Map k a)

HasSize (HashMap k a)

HasSize (SetWith k a)

HasSize (SetsWith k c a)

Relation

class CanBeSubset s where

Methods

isSubsetOf :: s -> s -> Bool

Instances

CanBeSubset IntSet

Eq a => CanBeSubset (IntMap a)

Ord a => CanBeSubset (Set a)

Ord a => CanBeSubset (FiniteSet a)

Eq a => CanBeSubset (UUSet a)

Eq a => CanBeSubset (UMSet a)

Eq a => CanBeSubset (OMSet a)

CanBeSubset a => CanBeSubset (XUnion a)

CanBeSubset a => CanBeSubset (Intersection a)

CanBeSubset a => CanBeSubset (Union a)

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

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

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

class CanBeProperSubset s where

Methods

isProperSubsetOf :: s -> s -> Bool

Instances

CanBeProperSubset IntSet

Eq a => CanBeProperSubset (IntMap a)

Ord a => CanBeProperSubset (Set a)

Ord a => CanBeProperSubset (FiniteSet a)

Eq a => CanBeProperSubset (UUSet a)

Eq a => CanBeProperSubset (UMSet a)

Eq a => CanBeProperSubset (OMSet a)

CanBeProperSubset a => CanBeProperSubset (XUnion a)

CanBeProperSubset a => CanBeProperSubset (Intersection a)

CanBeProperSubset a => CanBeProperSubset (Union a)

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

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

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

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