Data.Flags

This module provides type classes for working with sets of flags. In particular, with wrappers around bit masks:

 import Data.Flags

 newtype MyFlags = MyFlags CInt deriving (Eq, Flags)

 #{enum MyFlags, MyFlags
  , myFlag1 = C_FLAG1
  , myFlag2 = C_FLAG2
  , myFlag3 = C_FLAG3
  }

 f :: MyFlags -> IO ()
 f = ...

Or, using Template Haskell:

 import Data.Flags.TH

 $(bitmaskWrapper "MyFlags" ''CInt [] False
     [("myFlag1", #{const C_FLAG1}),
      ("myFlag2", #{const C_FLAG2}),
      ("myFlag3", #{const C_FLAG3})])

And then use it like this:

 f $ myFlag1 .+. myFlag3

Documentation

class Eq a => Flags a where

Methods

noFlags :: a

The empty set of flags.

andFlags :: a -> a -> a

Union of two flag sets.

butFlags :: a -> a -> a

Difference between two flag sets.

commonFlags :: a -> a -> a

Intersection of two flag sets.

Instances

Flags Int

Flags Int8

Flags Int16

Flags Int32

Flags Int64

Flags Integer

Flags Word

Flags Word8

Flags Word16

Flags Word32

Flags Word64

Flags WordPtr

Flags IntPtr

Flags CChar

Flags CSChar

Flags CUChar

Flags CShort

Flags CUShort

Flags CInt

Flags CUInt

Flags CLong

Flags CULong

Flags CLLong

Flags CULLong

(.+.) :: Flags a => a -> a -> a

Alias for andFlags.

(.-.) :: Flags a => a -> a -> a

Alias for butFlags.

(.*.) :: Flags a => a -> a -> a

Alias for commonFlags.

class Flags a => BoundedFlags a where

Use this class when the set of flags is fixed and not likely to change in the future.

Methods

allFlags :: a

Set of all flags.

enumFlags :: a -> [a]

List the individual flags.

Instances

BoundedFlags Int

BoundedFlags Int8

BoundedFlags Int16

BoundedFlags Int32

BoundedFlags Int64

BoundedFlags Word

BoundedFlags Word8

BoundedFlags Word16

BoundedFlags Word32

BoundedFlags Word64

BoundedFlags WordPtr

BoundedFlags IntPtr

BoundedFlags CChar

BoundedFlags CSChar

BoundedFlags CUChar

BoundedFlags CShort

BoundedFlags CUShort

BoundedFlags CInt

BoundedFlags CUInt

BoundedFlags CLong

BoundedFlags CULong

BoundedFlags CLLong

BoundedFlags CULLong

allBut :: BoundedFlags a => a -> a

Shorthand for allFlags .-. x.

containsAll :: Flags a => a -> a -> Bool

Test if the first flag set contains all flags from the second.

(.<=.) :: Flags a => a -> a -> Bool

Shorthand for flip containsAll.

(.>=.) :: Flags a => a -> a -> Bool

Alias for containsAll.

containsSome :: Flags a => a -> a -> Bool

Test if two flag sets intersect.

(.~.) :: Flags a => a -> a -> Bool

Alias for containsSome.

containsNone :: Flags a => a -> a -> Bool

Test if two flag sets do not intersect.

(./~.) :: Flags a => a -> a -> Bool

Alias for containsNone.