Util.SetLike

Documentation

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

class Monoid s => Unionize s where

Methods

union :: s -> s -> s

difference :: s -> s -> s

intersection :: s -> s -> s

unions :: [s] -> s

sempty :: s

Instances

Unionize IntSet

Unionize BitSet

Unionize Properties

Unionize (IntMap v)

Ord k => Unionize (Set k)

Unionize (IntjectionSet a)

Unionize (EnumSet a)

Unionize (GSet Char)

Unionize (GSet Int)

Unionize (GSet Atom)

Unionize (GSet Var)

Unionize (EnumBitSet a)

Ord k => Unionize (Map k v)

Unionize (IntjectionMap k v)

Unionize (EnumMap k v)

(Ord a, Ord b) => Unionize (Rel a b)

Unionize (GMap Char v)

Unionize (GMap Int v)

Unionize (GMap Atom v)

Unionize (GMap Var v)

type family Elem es :: *

type family Key s :: *

type family Value m :: *

class Monoid s => Collection s where

Methods

fromList :: [Elem s] -> s

fromDistinctAscList :: [Elem s] -> s

toList :: s -> [Elem s]

singleton :: Elem s -> s

Instances

Collection IntSet

Collection BitSet

Collection Properties

Collection (IntMap v)

Ord k => Collection (Set k)

Intjection a => Collection (IntjectionSet a)

Enum a => Collection (EnumSet a)

Collection (GSet Char)

Collection (GSet Int)

Collection (GSet Atom)

Collection (GSet Var)

Enum a => Collection (EnumBitSet a)

Ord k => Collection (Map k v)

Intjection k => Collection (IntjectionMap k v)

Enum k => Collection (EnumMap k v)

(Ord a, Ord b) => Collection (Rel a b)

Collection (GMap Char v)

Collection (GMap Int v)

Collection (GMap Atom v)

Collection (GMap Var v)

class Collection s => SetLike s where

Methods

keys :: s -> [Key s]

member :: Key s -> s -> Bool

delete :: Key s -> s -> s

sfilter :: (Elem s -> Bool) -> s -> s

insert :: Elem s -> s -> s

spartition :: (Elem s -> Bool) -> s -> (s, s)

Instances

SetLike IntSet

SetLike BitSet

SetLike Properties

SetLike (IntMap v)

Ord k => SetLike (Set k)

Intjection a => SetLike (IntjectionSet a)

Enum a => SetLike (EnumSet a)

SetLike (GSet Char)

SetLike (GSet Int)

SetLike (GSet Atom)

SetLike (GSet Var)

Enum a => SetLike (EnumBitSet a)

Ord k => SetLike (Map k v)

Intjection k => SetLike (IntjectionMap k v)

Enum k => SetLike (EnumMap k v)

SetLike (GMap Char v)

SetLike (GMap Int v)

SetLike (GMap Atom v)

SetLike (GMap Var v)

notMember :: SetLike s => Key s -> s -> Bool

class SetLike m => MapLike m where

Methods

mlookup :: Key m -> m -> Maybe (Value m)

values :: m -> [Value m]

unionWith :: (Value m -> Value m -> Value m) -> m -> m -> m

Instances

MapLike (IntMap v)

Ord k => MapLike (Map k v)

Intjection k => MapLike (IntjectionMap k v)

Enum k => MapLike (EnumMap k v)

MapLike (GMap Char v)

MapLike (GMap Int v)

MapLike (GMap Atom v)

MapLike (GMap Var v)

minsert :: (MapLike m, Elem m ~ (k, v)) => k -> v -> m -> m

msingleton :: (MapLike m, Elem m ~ (k, v)) => k -> v -> m

intersects :: (IsEmpty a, Unionize a) => a -> a -> Bool

findWithDefault :: MapLike m => Value m -> Key m -> m -> Value m

newtype EnumSet a

Constructors

EnumSet IntSet

Instances

Eq (EnumSet a)

Ord (EnumSet a)

Monoid (EnumSet a)

HasSize (EnumSet a)

IsEmpty (EnumSet a)

Enum a => SetLike (EnumSet a)

Enum a => Collection (EnumSet a)

Unionize (EnumSet a)

newtype EnumMap k v

Constructors

EnumMap (IntMap v)

Instances

Functor (EnumMap k)

Foldable (EnumMap k)

Traversable (EnumMap k)

Eq v => Eq (EnumMap k v)

Ord v => Ord (EnumMap k v)

Monoid (EnumMap k v)

HasSize (EnumMap k v)

IsEmpty (EnumMap k v)

Enum k => MapLike (EnumMap k v)

Enum k => SetLike (EnumMap k v)

Enum k => Collection (EnumMap k v)

Unionize (EnumMap k v)

class Intjection a where

Methods

fromIntjection :: a -> Int

toIntjection :: Int -> a

Instances

Intjection Atom

Intjection Var

Intjection Id

newtype IntjectionSet a

Constructors

IntjectionSet IntSet

Instances

Show IdSet

Binary IdSet

FreeVars TVr IdSet

determine free variables of a binding site

FreeVars E IdSet

FreeVars ARules IdSet

FreeVars Rule IdSet

we delete the free variables of the heads of a rule from the rule's free variables. the reason for doing this is that the rule cannot fire if all its heads are in scope, and if it were not done then many functions seem recursive when they arn't actually.

FreeVars Comb IdSet

Eq (IntjectionSet a)

Ord (IntjectionSet a)

(Intjection a, Show a) => Show (IntjectionSet a)

Monoid (IntjectionSet a)

HasSize (IntjectionSet a)

IsEmpty (IntjectionSet a)

Intjection a => SetLike (IntjectionSet a)

Intjection a => Collection (IntjectionSet a)

Unionize (IntjectionSet a)

FreeVars (Alt E) IdSet

newtype IntjectionMap k v

Constructors

IntjectionMap (IntMap v)

Instances

FreeVars E (IdMap (Maybe E))

FreeVars E (IdMap TVr)

Functor (IntjectionMap k)

Show v => Show (IdMap v)

Foldable (IntjectionMap k)

Traversable (IntjectionMap k)

Binary a => Binary (IdMap a)

FreeVars (Alt E) (IdMap TVr)

Eq v => Eq (IntjectionMap k v)

Ord v => Ord (IntjectionMap k v)

Monoid (IntjectionMap k v)

HasSize (IntjectionMap k v)

IsEmpty (IntjectionMap k v)

Intjection k => MapLike (IntjectionMap k v)

Intjection k => SetLike (IntjectionMap k v)

Intjection k => Collection (IntjectionMap k v)

Unionize (IntjectionMap k v)