Data.EnumSet

Similar to Data.Edison.Coll.EnumSet but it allows to choose the underlying type for bit storage. This is really a low-level module for type-safe foreign function interfaces.

The integer representation of the enumeration type is the bit position of the flag within the bitvector.

Documentation

newtype T word index

Constructors

Cons

Fields

• decons :: word

Instances

Eq word => Eq (T word index)

Methods

(==) :: T word index -> T word index -> Bool

(/=) :: T word index -> T word index -> Bool

(Enum a, Bits w) => Semigroup (T w a)

Methods

(<>) :: T w a -> T w a -> T w a

sconcat :: NonEmpty (T w a) -> T w a

stimes :: Integral b => b -> T w a -> T w a

(Enum a, Bits w) => Monoid (T w a)

Since this data type is intended for constructing flags, we choose the set union as mappend. For intersection we would also not have a canonical identity element.

Methods

mempty :: T w a

mappend :: T w a -> T w a -> T w a

mconcat :: [T w a] -> T w a

(Enum a, Storable w) => Storable (T w a)

Methods

sizeOf :: T w a -> Int

alignment :: T w a -> Int

peekElemOff :: Ptr (T w a) -> Int -> IO (T w a)

pokeElemOff :: Ptr (T w a) -> Int -> T w a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (T w a)

pokeByteOff :: Ptr b -> Int -> T w a -> IO ()

peek :: Ptr (T w a) -> IO (T w a)

poke :: Ptr (T w a) -> T w a -> IO ()

fromEnum :: (Enum a, Bits w) => a -> T w a

fromEnums :: (Enum a, Bits w) => [a] -> T w a

toEnums :: (Enum a, Bits w) => T w a -> [a]

intToEnums :: (Enum a, Integral w) => T w a -> [a]

mostSignificantPosition :: (Bits w, Storable w) => T w a -> Int

floor of binary logarithm - Intended for getting the position of a single set bit. This in turn is intended for implementing an Enum instance if you only know masks but no bit positions.

singletonByPosition :: Bits w => Int -> T w a

set a bit - Intended for implementing an Enum instance if you only know masks but no bit positions.

null :: (Enum a, Bits w) => T w a -> Bool

empty :: (Enum a, Bits w) => T w a

singleton :: (Enum a, Bits w) => a -> T w a

disjoint :: (Enum a, Bits w) => T w a -> T w a -> Bool

subset :: (Enum a, Bits w) => T w a -> T w a -> Bool

subset a b is True if a is a subset of b.

(.&.) :: (Enum a, Bits w) => T w a -> T w a -> T w a infixl 7

(.-.) :: (Enum a, Bits w) => T w a -> T w a -> T w a infixl 7

(.|.) :: (Enum a, Bits w) => T w a -> T w a -> T w a infixl 5

xor :: (Enum a, Bits w) => T w a -> T w a -> T w a

unions :: (Enum a, Bits w) => [T w a] -> T w a

get :: (Enum a, Bits w) => a -> T w a -> Bool

could also be named member like in Set or elem as in '[]'

put :: (Enum a, Bits w) => a -> Bool -> T w a -> T w a

accessor :: (Enum a, Bits w) => a -> T (T w a) Bool

set :: (Enum a, Bits w) => a -> T w a -> T w a

could also be named insert like in Set

clear :: (Enum a, Bits w) => a -> T w a -> T w a

could also be named delete like in Set

flip :: (Enum a, Bits w) => a -> T w a -> T w a

fromBool :: (Enum a, Bits w) => a -> Bool -> T w a