-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A package for working with bit masks and flags in general.
--   
--   This package provides type classes for flags and corresponding
--   instances for standard numeric types viewed as bit masks.
@package data-flags
@version 0.0.3.1


-- | Template Haskell utils for declaring flags instances.
module Data.Flags.TH

-- | Produces <a>Flags</a> instance declaration for the specified instance
--   of <a>Bits</a>.
dataBitsAsFlags :: Name -> Q [Dec]

-- | Produces <a>Flags</a> and <a>BoundedFlags</a> instances declarations
--   for the specified instance of <a>Bits</a>.
dataBitsAsBoundedFlags :: Name -> Q [Dec]

-- | Declare a newtype wrapper around the specified integral type and make
--   it an instance of <a>BoundedFlags</a>. For each individual flag
--   declare a constant. If a <a>Show</a> instance wasn't requested for
--   automatic derivation, declare one with
--   
--   <pre>
--   show flags = "WrappingTypeName [IndividualFlags in flags]"
--   </pre>
bitmaskWrapper :: String -> Name -> [Name] -> [(String, Integer)] -> Q [Dec]

-- | Declare an ADT with the specified constructors and make it an instance
--   of <a>Eq</a>, <a>Ord</a>, <a>Show</a> and <a>Storable</a>.
enumADT :: String -> Name -> [(String, Integer)] -> Q [Dec]


-- | This module provides type classes for working with sets of flags. In
--   particular, with wrappers around bit masks:
--   
--   <pre>
--   import Data.Flags
--   
--   newtype MyFlags = MyFlags CInt deriving (Eq, Flags)
--   
--   #{enum MyFlags, MyFlags
--    , myFlag1 = C_FLAG1
--    , myFlag2 = C_FLAG2
--    , myFlag3 = C_FLAG3
--    }
--   
--   f :: MyFlags -&gt; IO ()
--   f = ...
--   </pre>
--   
--   Or, using Template Haskell:
--   
--   <pre>
--   import Data.Flags.TH
--   
--   $(bitmaskWrapper "MyFlags" ''CInt [] False
--       [("myFlag1", #{const C_FLAG1}),
--        ("myFlag2", #{const C_FLAG2}),
--        ("myFlag3", #{const C_FLAG3})])
--   </pre>
--   
--   And then use it like this:
--   
--   <pre>
--   f $ myFlag1 .+. myFlag3
--   </pre>
module Data.Flags
class Eq a => Flags a
noFlags :: Flags a => a
andFlags :: Flags a => a -> a -> a
butFlags :: Flags a => a -> a -> a
commonFlags :: Flags a => a -> a -> a

-- | Alias for <a>andFlags</a>.
(.+.) :: Flags a => a -> a -> a

-- | Alias for <a>butFlags</a>.
(.-.) :: Flags a => a -> a -> a

-- | Alias for <a>commonFlags</a>.
(.*.) :: Flags a => a -> a -> a

-- | Use this class when the set of flags is fixed and not likely to change
--   in the future.
class Flags a => BoundedFlags a
allFlags :: BoundedFlags a => a
enumFlags :: BoundedFlags a => a -> [a]

-- | Shorthand for <a>allFlags</a> <a>.-.</a> <i>x</i>.
allBut :: BoundedFlags a => a -> a

-- | Test if the first flag set contains all flags from the second.
containsAll :: Flags a => a -> a -> Bool

-- | Shorthand for <a>flip</a> <a>containsAll</a>.
(.<=.) :: Flags a => a -> a -> Bool

-- | Alias for <a>containsAll</a>.
(.>=.) :: Flags a => a -> a -> Bool

-- | Test if two flag sets intersect.
containsSome :: Flags a => a -> a -> Bool

-- | Alias for <a>containsSome</a>.
(.~.) :: Flags a => a -> a -> Bool

-- | Test if two flag sets do not intersect.
containsNone :: Flags a => a -> a -> Bool

-- | Alias for <a>containsNone</a>.
(./~.) :: Flags a => a -> a -> Bool
instance BoundedFlags CULLong
instance Flags CULLong
instance BoundedFlags CLLong
instance Flags CLLong
instance BoundedFlags CULong
instance Flags CULong
instance BoundedFlags CLong
instance Flags CLong
instance BoundedFlags CUInt
instance Flags CUInt
instance BoundedFlags CInt
instance Flags CInt
instance BoundedFlags CUShort
instance Flags CUShort
instance BoundedFlags CShort
instance Flags CShort
instance BoundedFlags CUChar
instance Flags CUChar
instance BoundedFlags CSChar
instance Flags CSChar
instance BoundedFlags CChar
instance Flags CChar
instance BoundedFlags WordPtr
instance Flags WordPtr
instance BoundedFlags IntPtr
instance Flags IntPtr
instance BoundedFlags Word64
instance Flags Word64
instance BoundedFlags Word32
instance Flags Word32
instance BoundedFlags Word16
instance Flags Word16
instance BoundedFlags Word8
instance Flags Word8
instance BoundedFlags Word
instance Flags Word
instance BoundedFlags Int64
instance Flags Int64
instance BoundedFlags Int32
instance Flags Int32
instance BoundedFlags Int16
instance Flags Int16
instance BoundedFlags Int8
instance Flags Int8
instance BoundedFlags Int
instance Flags Int
instance Flags Integer