{-# LANGUAGE FlexibleInstances, GeneralizedNewtypeDeriving,
             DeriveDataTypeable
  #-}
module Data.Algebra.Boolean
       ( Boolean(..), fromBool, Bitwise(..)
       ) where
import Data.Monoid (Any(..), All(..), Dual(..), Endo(..))
import Data.Bits (Bits, complement, (.|.), (.&.))
import qualified Data.Bits as Bits
import Data.Function (on)
import Data.Typeable
import Data.Data
import Data.Ix
import Data.Foldable (Foldable)
import qualified Data.Foldable as F
import Foreign.Storable
import Text.Printf
import Prelude hiding ((&&), (||), not, and, or, any, all)
import qualified Prelude as P

infixr  1 <-->, `xor`, -->
infixr  2 ||
infixr  3 &&

-- |A class for boolean algebras. Instances of this class are expected to obey
-- all the laws of boolean algebra.
--
-- Minimal complete definition: 'true' or 'false', 'not' or '<-->', '||' or '&&'.
class Boolean b where
  -- |Truth value, defined as the top of the bounded lattice
  true    :: b
  -- |False value, defined as the bottom of the bounded lattice.
  false   :: b
  -- |Logical negation.
  not     :: b -> b
  -- |Logical conjunction. (infxr 3)
  (&&)    :: b -> b -> b
  -- |Logical inclusive disjunction. (infixr 2)
  (||)    :: b -> b -> b
  -- |Logical exclusive disjunction. (infixr 1)
  xor   :: b -> b -> b
  -- |Logical implication. (infixr 1)
  (-->) :: b -> b -> b
  -- |Logical biconditional. (infixr 1)
  (<-->) :: b -> b -> b

  -- | The logical conjunction of several values.
  and :: Foldable t => t b -> b

  -- | The logical disjunction of several values.
  or :: Foldable t => t b -> b

  -- | The negated logical conjunction of several values.
  --
  -- @'nand' = 'not' . 'and'@
  nand :: Foldable t => t b -> b
  nand = b -> b
forall b. Boolean b => b -> b
not (b -> b) -> (t b -> b) -> t b -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t b -> b
forall b (t :: * -> *). (Boolean b, Foldable t) => t b -> b
forall (t :: * -> *). Foldable t => t b -> b
and

  -- | The logical conjunction of the mapping of a function over several values.
  all :: Foldable t => (a -> b) -> t a -> b

  -- | The logical disjunction of the mapping of a function over several values.
  any :: Foldable t => (a -> b) -> t a -> b

  -- | The negated logical disjunction of several values.
  --
  -- @'nor' = 'not' . 'or'@
  nor :: Foldable t => t b -> b
  nor = b -> b
forall b. Boolean b => b -> b
not (b -> b) -> (t b -> b) -> t b -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t b -> b
forall b (t :: * -> *). (Boolean b, Foldable t) => t b -> b
forall (t :: * -> *). Foldable t => t b -> b
or

  -- Default implementations
  true      = b -> b
forall b. Boolean b => b -> b
not b
forall b. Boolean b => b
false
  false     = b -> b
forall b. Boolean b => b -> b
not b
forall b. Boolean b => b
true
  not       = (b -> b -> b
forall b. Boolean b => b -> b -> b
<--> b
forall b. Boolean b => b
false)
  b
x && b
y = b -> b
forall b. Boolean b => b -> b
not (b -> b
forall b. Boolean b => b -> b
not b
x b -> b -> b
forall b. Boolean b => b -> b -> b
|| b -> b
forall b. Boolean b => b -> b
not b
y)
  b
x || b
y = b -> b
forall b. Boolean b => b -> b
not (b -> b
forall b. Boolean b => b -> b
not b
x b -> b -> b
forall b. Boolean b => b -> b -> b
&& b -> b
forall b. Boolean b => b -> b
not b
y)
  b
x `xor` b
y = (b
x b -> b -> b
forall b. Boolean b => b -> b -> b
|| b
y) b -> b -> b
forall b. Boolean b => b -> b -> b
&& (b -> b
forall b. Boolean b => b -> b
not (b
x b -> b -> b
forall b. Boolean b => b -> b -> b
&& b
y))
  b
x --> b
y   = b -> b
forall b. Boolean b => b -> b
not b
x b -> b -> b
forall b. Boolean b => b -> b -> b
|| b
y
  b
x <--> b
y  = (b
x b -> b -> b
forall b. Boolean b => b -> b -> b
&& b
y) b -> b -> b
forall b. Boolean b => b -> b -> b
|| b -> b
forall b. Boolean b => b -> b
not (b
x b -> b -> b
forall b. Boolean b => b -> b -> b
|| b
y)
  and       = (b -> b -> b) -> b -> t b -> b
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' b -> b -> b
forall b. Boolean b => b -> b -> b
(&&) b
forall b. Boolean b => b
true
  or        = (b -> b -> b) -> b -> t b -> b
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' b -> b -> b
forall b. Boolean b => b -> b -> b
(||) b
forall b. Boolean b => b
false
  all a -> b
p     = (b -> a -> b) -> b -> t a -> b
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' b -> a -> b
f b
forall b. Boolean b => b
true
    where f :: b -> a -> b
f b
a a
b = b
a b -> b -> b
forall b. Boolean b => b -> b -> b
&& a -> b
p a
b
  any a -> b
p     = (b -> a -> b) -> b -> t a -> b
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' b -> a -> b
f b
forall b. Boolean b => b
false
    where f :: b -> a -> b
f b
a a
b = b
a b -> b -> b
forall b. Boolean b => b -> b -> b
|| a -> b
p a
b


-- |Injection from 'Bool' into a boolean algebra.
fromBool :: Boolean b => Bool -> b
fromBool :: forall b. Boolean b => Bool -> b
fromBool Bool
b = if Bool
b then b
forall b. Boolean b => b
true else b
forall b. Boolean b => b
false

instance Boolean Bool where
  true :: Bool
true = Bool
True
  false :: Bool
false = Bool
False
  && :: Bool -> Bool -> Bool
(&&) = Bool -> Bool -> Bool
(P.&&)
  || :: Bool -> Bool -> Bool
(||) = Bool -> Bool -> Bool
(P.||)
  not :: Bool -> Bool
not = Bool -> Bool
P.not
  xor :: Bool -> Bool -> Bool
xor = Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
(/=)
  Bool
True  --> :: Bool -> Bool -> Bool
--> Bool
True  = Bool
True
  Bool
True  --> Bool
False = Bool
False
  Bool
False --> Bool
_     = Bool
True
  <--> :: Bool -> Bool -> Bool
(<-->) = Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
(==)

instance Boolean Any where
  true :: Any
true                  = Bool -> Any
Any Bool
True
  false :: Any
false                 = Bool -> Any
Any Bool
False
  not :: Any -> Any
not (Any Bool
p)           = Bool -> Any
Any (Bool -> Bool
forall b. Boolean b => b -> b
not Bool
p)
  (Any Bool
p) && :: Any -> Any -> Any
&&    (Any Bool
q) = Bool -> Any
Any (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
&& Bool
q)
  (Any Bool
p) || :: Any -> Any -> Any
||    (Any Bool
q) = Bool -> Any
Any (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
|| Bool
q)
  (Any Bool
p) xor :: Any -> Any -> Any
`xor` (Any Bool
q) = Bool -> Any
Any (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
`xor` Bool
q)
  (Any Bool
p) --> :: Any -> Any -> Any
--> (Any Bool
q)   = Bool -> Any
Any (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
--> Bool
q)
  (Any Bool
p) <--> :: Any -> Any -> Any
<--> (Any Bool
q)  = Bool -> Any
Any (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
<--> Bool
q)

instance Boolean All where
  true :: All
true                  = Bool -> All
All Bool
True
  false :: All
false                 = Bool -> All
All Bool
False
  not :: All -> All
not (All Bool
p)           = Bool -> All
All (Bool -> Bool
forall b. Boolean b => b -> b
not Bool
p)
  (All Bool
p) && :: All -> All -> All
&& (All Bool
q)    = Bool -> All
All (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
&& Bool
q)
  (All Bool
p) || :: All -> All -> All
|| (All Bool
q)    = Bool -> All
All (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
|| Bool
q)
  (All Bool
p) xor :: All -> All -> All
`xor` (All Bool
q) = Bool -> All
All (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
`xor` Bool
q)
  (All Bool
p) --> :: All -> All -> All
--> (All Bool
q)   = Bool -> All
All (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
--> Bool
q)
  (All Bool
p) <--> :: All -> All -> All
<--> (All Bool
q)  = Bool -> All
All (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
<--> Bool
q)

instance Boolean (Dual Bool) where
  true :: Dual Bool
true                    = Bool -> Dual Bool
forall a. a -> Dual a
Dual Bool
True
  false :: Dual Bool
false                   = Bool -> Dual Bool
forall a. a -> Dual a
Dual Bool
False
  not :: Dual Bool -> Dual Bool
not (Dual Bool
p)            = Bool -> Dual Bool
forall a. a -> Dual a
Dual (Bool -> Bool
forall b. Boolean b => b -> b
not Bool
p)
  (Dual Bool
p) && :: Dual Bool -> Dual Bool -> Dual Bool
&& (Dual Bool
q)    = Bool -> Dual Bool
forall a. a -> Dual a
Dual (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
&& Bool
q)
  (Dual Bool
p) || :: Dual Bool -> Dual Bool -> Dual Bool
|| (Dual Bool
q)    = Bool -> Dual Bool
forall a. a -> Dual a
Dual (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
|| Bool
q)
  (Dual Bool
p) xor :: Dual Bool -> Dual Bool -> Dual Bool
`xor` (Dual Bool
q) = Bool -> Dual Bool
forall a. a -> Dual a
Dual (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
`xor` Bool
q)
  (Dual Bool
p) --> :: Dual Bool -> Dual Bool -> Dual Bool
--> (Dual Bool
q)   = Bool -> Dual Bool
forall a. a -> Dual a
Dual (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
--> Bool
q)
  (Dual Bool
p) <--> :: Dual Bool -> Dual Bool -> Dual Bool
<--> (Dual Bool
q)  = Bool -> Dual Bool
forall a. a -> Dual a
Dual (Bool
p Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
<--> Bool
q)

instance Boolean (Endo Bool) where
  true :: Endo Bool
true                    = (Bool -> Bool) -> Endo Bool
forall a. (a -> a) -> Endo a
Endo (Bool -> Bool -> Bool
forall a b. a -> b -> a
const Bool
True)
  false :: Endo Bool
false                   = (Bool -> Bool) -> Endo Bool
forall a. (a -> a) -> Endo a
Endo (Bool -> Bool -> Bool
forall a b. a -> b -> a
const Bool
False)
  not :: Endo Bool -> Endo Bool
not (Endo Bool -> Bool
p)            = (Bool -> Bool) -> Endo Bool
forall a. (a -> a) -> Endo a
Endo (Bool -> Bool
forall b. Boolean b => b -> b
not (Bool -> Bool) -> (Bool -> Bool) -> Bool -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bool
p)
  (Endo Bool -> Bool
p) && :: Endo Bool -> Endo Bool -> Endo Bool
&& (Endo Bool -> Bool
q)    = (Bool -> Bool) -> Endo Bool
forall a. (a -> a) -> Endo a
Endo (\Bool
a -> Bool -> Bool
p Bool
a Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
&& Bool -> Bool
q Bool
a)
  (Endo Bool -> Bool
p) || :: Endo Bool -> Endo Bool -> Endo Bool
|| (Endo Bool -> Bool
q)    = (Bool -> Bool) -> Endo Bool
forall a. (a -> a) -> Endo a
Endo (\Bool
a -> Bool -> Bool
p Bool
a Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
|| Bool -> Bool
q Bool
a)
  (Endo Bool -> Bool
p) xor :: Endo Bool -> Endo Bool -> Endo Bool
`xor` (Endo Bool -> Bool
q) = (Bool -> Bool) -> Endo Bool
forall a. (a -> a) -> Endo a
Endo (\Bool
a -> Bool -> Bool
p Bool
a Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
`xor` Bool -> Bool
q Bool
a)
  (Endo Bool -> Bool
p) --> :: Endo Bool -> Endo Bool -> Endo Bool
--> (Endo Bool -> Bool
q)   = (Bool -> Bool) -> Endo Bool
forall a. (a -> a) -> Endo a
Endo (\Bool
a -> Bool -> Bool
p Bool
a Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
--> Bool -> Bool
q Bool
a)
  (Endo Bool -> Bool
p) <--> :: Endo Bool -> Endo Bool -> Endo Bool
<--> (Endo Bool -> Bool
q)  = (Bool -> Bool) -> Endo Bool
forall a. (a -> a) -> Endo a
Endo (\Bool
a -> Bool -> Bool
p Bool
a Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
<--> Bool -> Bool
q Bool
a)

instance (Boolean x, Boolean y) => Boolean (x, y) where
  true :: (x, y)
true                = (x
forall b. Boolean b => b
true, y
forall b. Boolean b => b
true)
  false :: (x, y)
false               = (x
forall b. Boolean b => b
false, y
forall b. Boolean b => b
false)
  not :: (x, y) -> (x, y)
not (x
a, y
b)          = (x -> x
forall b. Boolean b => b -> b
not x
a, y -> y
forall b. Boolean b => b -> b
not y
b)
  (x
a, y
b) && :: (x, y) -> (x, y) -> (x, y)
&& (x
c, y
d)    = (x
a x -> x -> x
forall b. Boolean b => b -> b -> b
&& x
c, y
b y -> y -> y
forall b. Boolean b => b -> b -> b
&& y
d)
  (x
a, y
b) || :: (x, y) -> (x, y) -> (x, y)
|| (x
c, y
d)    = (x
a x -> x -> x
forall b. Boolean b => b -> b -> b
|| x
c, y
b y -> y -> y
forall b. Boolean b => b -> b -> b
|| y
d)
  (x
a, y
b) xor :: (x, y) -> (x, y) -> (x, y)
`xor` (x
c, y
d) = (x
a x -> x -> x
forall b. Boolean b => b -> b -> b
`xor` x
c, y
b y -> y -> y
forall b. Boolean b => b -> b -> b
`xor` y
d)
  (x
a, y
b) --> :: (x, y) -> (x, y) -> (x, y)
--> (x
c, y
d)   = (x
a x -> x -> x
forall b. Boolean b => b -> b -> b
--> x
c, y
b y -> y -> y
forall b. Boolean b => b -> b -> b
--> y
d)
  (x
a, y
b) <--> :: (x, y) -> (x, y) -> (x, y)
<--> (x
c, y
d)  = (x
a x -> x -> x
forall b. Boolean b => b -> b -> b
<--> x
c, y
b y -> y -> y
forall b. Boolean b => b -> b -> b
<--> y
d)

-- |A newtype wrapper that derives a 'Boolean' instance from any type that is both
-- a 'Bits' instance and a 'Num' instance,
-- such that boolean logic operations on the 'Bitwise' wrapper correspond to
-- bitwise logic operations on the inner type. It should be noted that 'false' is
-- defined as 'Bitwise' 0 and 'true' is defined as 'not' 'false'.
--
-- In addition, a number of other classes are automatically derived from the inner
-- type. These classes were chosen on the basis that many other 'Bits'
-- instances defined in base are also instances of these classes.
newtype Bitwise a = Bitwise {forall a. Bitwise a -> a
getBits :: a}
                  deriving (Integer -> Bitwise a
Bitwise a -> Bitwise a
Bitwise a -> Bitwise a -> Bitwise a
(Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a)
-> (Integer -> Bitwise a)
-> Num (Bitwise a)
forall a. Num a => Integer -> Bitwise a
forall a. Num a => Bitwise a -> Bitwise a
forall a. Num a => Bitwise a -> Bitwise a -> Bitwise a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: forall a. Num a => Bitwise a -> Bitwise a -> Bitwise a
+ :: Bitwise a -> Bitwise a -> Bitwise a
$c- :: forall a. Num a => Bitwise a -> Bitwise a -> Bitwise a
- :: Bitwise a -> Bitwise a -> Bitwise a
$c* :: forall a. Num a => Bitwise a -> Bitwise a -> Bitwise a
* :: Bitwise a -> Bitwise a -> Bitwise a
$cnegate :: forall a. Num a => Bitwise a -> Bitwise a
negate :: Bitwise a -> Bitwise a
$cabs :: forall a. Num a => Bitwise a -> Bitwise a
abs :: Bitwise a -> Bitwise a
$csignum :: forall a. Num a => Bitwise a -> Bitwise a
signum :: Bitwise a -> Bitwise a
$cfromInteger :: forall a. Num a => Integer -> Bitwise a
fromInteger :: Integer -> Bitwise a
Num, Eq (Bitwise a)
Bitwise a
Eq (Bitwise a)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a)
-> (Bitwise a -> Int -> Bitwise a)
-> (Bitwise a -> Int -> Bitwise a)
-> Bitwise a
-> (Int -> Bitwise a)
-> (Bitwise a -> Int -> Bitwise a)
-> (Bitwise a -> Int -> Bitwise a)
-> (Bitwise a -> Int -> Bitwise a)
-> (Bitwise a -> Int -> Bool)
-> (Bitwise a -> Maybe Int)
-> (Bitwise a -> Int)
-> (Bitwise a -> Bool)
-> (Bitwise a -> Int -> Bitwise a)
-> (Bitwise a -> Int -> Bitwise a)
-> (Bitwise a -> Int -> Bitwise a)
-> (Bitwise a -> Int -> Bitwise a)
-> (Bitwise a -> Int -> Bitwise a)
-> (Bitwise a -> Int -> Bitwise a)
-> (Bitwise a -> Int)
-> Bits (Bitwise a)
Int -> Bitwise a
Bitwise a -> Bool
Bitwise a -> Int
Bitwise a -> Maybe Int
Bitwise a -> Bitwise a
Bitwise a -> Int -> Bool
Bitwise a -> Int -> Bitwise a
Bitwise a -> Bitwise a -> Bitwise a
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
forall {a}. Bits a => Eq (Bitwise a)
forall a. Bits a => Bitwise a
forall a. Bits a => Int -> Bitwise a
forall a. Bits a => Bitwise a -> Bool
forall a. Bits a => Bitwise a -> Int
forall a. Bits a => Bitwise a -> Maybe Int
forall a. Bits a => Bitwise a -> Bitwise a
forall a. Bits a => Bitwise a -> Int -> Bool
forall a. Bits a => Bitwise a -> Int -> Bitwise a
forall a. Bits a => Bitwise a -> Bitwise a -> Bitwise a
$c.&. :: forall a. Bits a => Bitwise a -> Bitwise a -> Bitwise a
.&. :: Bitwise a -> Bitwise a -> Bitwise a
$c.|. :: forall a. Bits a => Bitwise a -> Bitwise a -> Bitwise a
.|. :: Bitwise a -> Bitwise a -> Bitwise a
$cxor :: forall a. Bits a => Bitwise a -> Bitwise a -> Bitwise a
xor :: Bitwise a -> Bitwise a -> Bitwise a
$ccomplement :: forall a. Bits a => Bitwise a -> Bitwise a
complement :: Bitwise a -> Bitwise a
$cshift :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
shift :: Bitwise a -> Int -> Bitwise a
$crotate :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
rotate :: Bitwise a -> Int -> Bitwise a
$czeroBits :: forall a. Bits a => Bitwise a
zeroBits :: Bitwise a
$cbit :: forall a. Bits a => Int -> Bitwise a
bit :: Int -> Bitwise a
$csetBit :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
setBit :: Bitwise a -> Int -> Bitwise a
$cclearBit :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
clearBit :: Bitwise a -> Int -> Bitwise a
$ccomplementBit :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
complementBit :: Bitwise a -> Int -> Bitwise a
$ctestBit :: forall a. Bits a => Bitwise a -> Int -> Bool
testBit :: Bitwise a -> Int -> Bool
$cbitSizeMaybe :: forall a. Bits a => Bitwise a -> Maybe Int
bitSizeMaybe :: Bitwise a -> Maybe Int
$cbitSize :: forall a. Bits a => Bitwise a -> Int
bitSize :: Bitwise a -> Int
$cisSigned :: forall a. Bits a => Bitwise a -> Bool
isSigned :: Bitwise a -> Bool
$cshiftL :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
shiftL :: Bitwise a -> Int -> Bitwise a
$cunsafeShiftL :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
unsafeShiftL :: Bitwise a -> Int -> Bitwise a
$cshiftR :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
shiftR :: Bitwise a -> Int -> Bitwise a
$cunsafeShiftR :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
unsafeShiftR :: Bitwise a -> Int -> Bitwise a
$crotateL :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
rotateL :: Bitwise a -> Int -> Bitwise a
$crotateR :: forall a. Bits a => Bitwise a -> Int -> Bitwise a
rotateR :: Bitwise a -> Int -> Bitwise a
$cpopCount :: forall a. Bits a => Bitwise a -> Int
popCount :: Bitwise a -> Int
Bits, Bitwise a -> Bitwise a -> Bool
(Bitwise a -> Bitwise a -> Bool)
-> (Bitwise a -> Bitwise a -> Bool) -> Eq (Bitwise a)
forall a. Eq a => Bitwise a -> Bitwise a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Bitwise a -> Bitwise a -> Bool
== :: Bitwise a -> Bitwise a -> Bool
$c/= :: forall a. Eq a => Bitwise a -> Bitwise a -> Bool
/= :: Bitwise a -> Bitwise a -> Bool
Eq, Eq (Bitwise a)
Eq (Bitwise a)
-> (Bitwise a -> Bitwise a -> Ordering)
-> (Bitwise a -> Bitwise a -> Bool)
-> (Bitwise a -> Bitwise a -> Bool)
-> (Bitwise a -> Bitwise a -> Bool)
-> (Bitwise a -> Bitwise a -> Bool)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> Ord (Bitwise a)
Bitwise a -> Bitwise a -> Bool
Bitwise a -> Bitwise a -> Ordering
Bitwise a -> Bitwise a -> Bitwise a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Bitwise a)
forall a. Ord a => Bitwise a -> Bitwise a -> Bool
forall a. Ord a => Bitwise a -> Bitwise a -> Ordering
forall a. Ord a => Bitwise a -> Bitwise a -> Bitwise a
$ccompare :: forall a. Ord a => Bitwise a -> Bitwise a -> Ordering
compare :: Bitwise a -> Bitwise a -> Ordering
$c< :: forall a. Ord a => Bitwise a -> Bitwise a -> Bool
< :: Bitwise a -> Bitwise a -> Bool
$c<= :: forall a. Ord a => Bitwise a -> Bitwise a -> Bool
<= :: Bitwise a -> Bitwise a -> Bool
$c> :: forall a. Ord a => Bitwise a -> Bitwise a -> Bool
> :: Bitwise a -> Bitwise a -> Bool
$c>= :: forall a. Ord a => Bitwise a -> Bitwise a -> Bool
>= :: Bitwise a -> Bitwise a -> Bool
$cmax :: forall a. Ord a => Bitwise a -> Bitwise a -> Bitwise a
max :: Bitwise a -> Bitwise a -> Bitwise a
$cmin :: forall a. Ord a => Bitwise a -> Bitwise a -> Bitwise a
min :: Bitwise a -> Bitwise a -> Bitwise a
Ord, Bitwise a
Bitwise a -> Bitwise a -> Bounded (Bitwise a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Bitwise a
$cminBound :: forall a. Bounded a => Bitwise a
minBound :: Bitwise a
$cmaxBound :: forall a. Bounded a => Bitwise a
maxBound :: Bitwise a
Bounded, Int -> Bitwise a
Bitwise a -> Int
Bitwise a -> [Bitwise a]
Bitwise a -> Bitwise a
Bitwise a -> Bitwise a -> [Bitwise a]
Bitwise a -> Bitwise a -> Bitwise a -> [Bitwise a]
(Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a)
-> (Int -> Bitwise a)
-> (Bitwise a -> Int)
-> (Bitwise a -> [Bitwise a])
-> (Bitwise a -> Bitwise a -> [Bitwise a])
-> (Bitwise a -> Bitwise a -> [Bitwise a])
-> (Bitwise a -> Bitwise a -> Bitwise a -> [Bitwise a])
-> Enum (Bitwise a)
forall a. Enum a => Int -> Bitwise a
forall a. Enum a => Bitwise a -> Int
forall a. Enum a => Bitwise a -> [Bitwise a]
forall a. Enum a => Bitwise a -> Bitwise a
forall a. Enum a => Bitwise a -> Bitwise a -> [Bitwise a]
forall a.
Enum a =>
Bitwise a -> Bitwise a -> Bitwise a -> [Bitwise a]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: forall a. Enum a => Bitwise a -> Bitwise a
succ :: Bitwise a -> Bitwise a
$cpred :: forall a. Enum a => Bitwise a -> Bitwise a
pred :: Bitwise a -> Bitwise a
$ctoEnum :: forall a. Enum a => Int -> Bitwise a
toEnum :: Int -> Bitwise a
$cfromEnum :: forall a. Enum a => Bitwise a -> Int
fromEnum :: Bitwise a -> Int
$cenumFrom :: forall a. Enum a => Bitwise a -> [Bitwise a]
enumFrom :: Bitwise a -> [Bitwise a]
$cenumFromThen :: forall a. Enum a => Bitwise a -> Bitwise a -> [Bitwise a]
enumFromThen :: Bitwise a -> Bitwise a -> [Bitwise a]
$cenumFromTo :: forall a. Enum a => Bitwise a -> Bitwise a -> [Bitwise a]
enumFromTo :: Bitwise a -> Bitwise a -> [Bitwise a]
$cenumFromThenTo :: forall a.
Enum a =>
Bitwise a -> Bitwise a -> Bitwise a -> [Bitwise a]
enumFromThenTo :: Bitwise a -> Bitwise a -> Bitwise a -> [Bitwise a]
Enum, Int -> Bitwise a -> ShowS
[Bitwise a] -> ShowS
Bitwise a -> String
(Int -> Bitwise a -> ShowS)
-> (Bitwise a -> String)
-> ([Bitwise a] -> ShowS)
-> Show (Bitwise a)
forall a. Show a => Int -> Bitwise a -> ShowS
forall a. Show a => [Bitwise a] -> ShowS
forall a. Show a => Bitwise a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Bitwise a -> ShowS
showsPrec :: Int -> Bitwise a -> ShowS
$cshow :: forall a. Show a => Bitwise a -> String
show :: Bitwise a -> String
$cshowList :: forall a. Show a => [Bitwise a] -> ShowS
showList :: [Bitwise a] -> ShowS
Show, ReadPrec [Bitwise a]
ReadPrec (Bitwise a)
Int -> ReadS (Bitwise a)
ReadS [Bitwise a]
(Int -> ReadS (Bitwise a))
-> ReadS [Bitwise a]
-> ReadPrec (Bitwise a)
-> ReadPrec [Bitwise a]
-> Read (Bitwise a)
forall a. Read a => ReadPrec [Bitwise a]
forall a. Read a => ReadPrec (Bitwise a)
forall a. Read a => Int -> ReadS (Bitwise a)
forall a. Read a => ReadS [Bitwise a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (Bitwise a)
readsPrec :: Int -> ReadS (Bitwise a)
$creadList :: forall a. Read a => ReadS [Bitwise a]
readList :: ReadS [Bitwise a]
$creadPrec :: forall a. Read a => ReadPrec (Bitwise a)
readPrec :: ReadPrec (Bitwise a)
$creadListPrec :: forall a. Read a => ReadPrec [Bitwise a]
readListPrec :: ReadPrec [Bitwise a]
Read, Num (Bitwise a)
Ord (Bitwise a)
Num (Bitwise a)
-> Ord (Bitwise a) -> (Bitwise a -> Rational) -> Real (Bitwise a)
Bitwise a -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall {a}. Real a => Num (Bitwise a)
forall {a}. Real a => Ord (Bitwise a)
forall a. Real a => Bitwise a -> Rational
$ctoRational :: forall a. Real a => Bitwise a -> Rational
toRational :: Bitwise a -> Rational
Real,
                            Enum (Bitwise a)
Real (Bitwise a)
Real (Bitwise a)
-> Enum (Bitwise a)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a -> (Bitwise a, Bitwise a))
-> (Bitwise a -> Bitwise a -> (Bitwise a, Bitwise a))
-> (Bitwise a -> Integer)
-> Integral (Bitwise a)
Bitwise a -> Integer
Bitwise a -> Bitwise a -> (Bitwise a, Bitwise a)
Bitwise a -> Bitwise a -> Bitwise a
forall {a}. Integral a => Enum (Bitwise a)
forall {a}. Integral a => Real (Bitwise a)
forall a. Integral a => Bitwise a -> Integer
forall a.
Integral a =>
Bitwise a -> Bitwise a -> (Bitwise a, Bitwise a)
forall a. Integral a => Bitwise a -> Bitwise a -> Bitwise a
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: forall a. Integral a => Bitwise a -> Bitwise a -> Bitwise a
quot :: Bitwise a -> Bitwise a -> Bitwise a
$crem :: forall a. Integral a => Bitwise a -> Bitwise a -> Bitwise a
rem :: Bitwise a -> Bitwise a -> Bitwise a
$cdiv :: forall a. Integral a => Bitwise a -> Bitwise a -> Bitwise a
div :: Bitwise a -> Bitwise a -> Bitwise a
$cmod :: forall a. Integral a => Bitwise a -> Bitwise a -> Bitwise a
mod :: Bitwise a -> Bitwise a -> Bitwise a
$cquotRem :: forall a.
Integral a =>
Bitwise a -> Bitwise a -> (Bitwise a, Bitwise a)
quotRem :: Bitwise a -> Bitwise a -> (Bitwise a, Bitwise a)
$cdivMod :: forall a.
Integral a =>
Bitwise a -> Bitwise a -> (Bitwise a, Bitwise a)
divMod :: Bitwise a -> Bitwise a -> (Bitwise a, Bitwise a)
$ctoInteger :: forall a. Integral a => Bitwise a -> Integer
toInteger :: Bitwise a -> Integer
Integral, Typeable, Typeable (Bitwise a)
Typeable (Bitwise a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bitwise a -> c (Bitwise a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bitwise a))
-> (Bitwise a -> Constr)
-> (Bitwise a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bitwise a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bitwise a)))
-> ((forall b. Data b => b -> b) -> Bitwise a -> Bitwise a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bitwise a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bitwise a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Bitwise a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Bitwise a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a))
-> Data (Bitwise a)
Bitwise a -> Constr
Bitwise a -> DataType
(forall b. Data b => b -> b) -> Bitwise a -> Bitwise a
forall {a}. Data a => Typeable (Bitwise a)
forall a. Data a => Bitwise a -> Constr
forall a. Data a => Bitwise a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Bitwise a -> Bitwise a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Bitwise a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Bitwise a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bitwise a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bitwise a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bitwise a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bitwise a -> c (Bitwise a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Bitwise a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Bitwise a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Bitwise a -> u
forall u. (forall d. Data d => d -> u) -> Bitwise a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bitwise a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bitwise a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bitwise a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bitwise a -> c (Bitwise a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Bitwise a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Bitwise a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bitwise a -> c (Bitwise a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bitwise a -> c (Bitwise a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bitwise a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bitwise a)
$ctoConstr :: forall a. Data a => Bitwise a -> Constr
toConstr :: Bitwise a -> Constr
$cdataTypeOf :: forall a. Data a => Bitwise a -> DataType
dataTypeOf :: Bitwise a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Bitwise a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Bitwise a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Bitwise a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Bitwise a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Bitwise a -> Bitwise a
gmapT :: (forall b. Data b => b -> b) -> Bitwise a -> Bitwise a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bitwise a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bitwise a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bitwise a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bitwise a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Bitwise a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Bitwise a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Bitwise a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bitwise a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bitwise a -> m (Bitwise a)
Data, Ord (Bitwise a)
Ord (Bitwise a)
-> ((Bitwise a, Bitwise a) -> [Bitwise a])
-> ((Bitwise a, Bitwise a) -> Bitwise a -> Int)
-> ((Bitwise a, Bitwise a) -> Bitwise a -> Int)
-> ((Bitwise a, Bitwise a) -> Bitwise a -> Bool)
-> ((Bitwise a, Bitwise a) -> Int)
-> ((Bitwise a, Bitwise a) -> Int)
-> Ix (Bitwise a)
(Bitwise a, Bitwise a) -> Int
(Bitwise a, Bitwise a) -> [Bitwise a]
(Bitwise a, Bitwise a) -> Bitwise a -> Bool
(Bitwise a, Bitwise a) -> Bitwise a -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall {a}. Ix a => Ord (Bitwise a)
forall a. Ix a => (Bitwise a, Bitwise a) -> Int
forall a. Ix a => (Bitwise a, Bitwise a) -> [Bitwise a]
forall a. Ix a => (Bitwise a, Bitwise a) -> Bitwise a -> Bool
forall a. Ix a => (Bitwise a, Bitwise a) -> Bitwise a -> Int
$crange :: forall a. Ix a => (Bitwise a, Bitwise a) -> [Bitwise a]
range :: (Bitwise a, Bitwise a) -> [Bitwise a]
$cindex :: forall a. Ix a => (Bitwise a, Bitwise a) -> Bitwise a -> Int
index :: (Bitwise a, Bitwise a) -> Bitwise a -> Int
$cunsafeIndex :: forall a. Ix a => (Bitwise a, Bitwise a) -> Bitwise a -> Int
unsafeIndex :: (Bitwise a, Bitwise a) -> Bitwise a -> Int
$cinRange :: forall a. Ix a => (Bitwise a, Bitwise a) -> Bitwise a -> Bool
inRange :: (Bitwise a, Bitwise a) -> Bitwise a -> Bool
$crangeSize :: forall a. Ix a => (Bitwise a, Bitwise a) -> Int
rangeSize :: (Bitwise a, Bitwise a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (Bitwise a, Bitwise a) -> Int
unsafeRangeSize :: (Bitwise a, Bitwise a) -> Int
Ix, Ptr (Bitwise a) -> IO (Bitwise a)
Ptr (Bitwise a) -> Int -> IO (Bitwise a)
Ptr (Bitwise a) -> Int -> Bitwise a -> IO ()
Ptr (Bitwise a) -> Bitwise a -> IO ()
Bitwise a -> Int
(Bitwise a -> Int)
-> (Bitwise a -> Int)
-> (Ptr (Bitwise a) -> Int -> IO (Bitwise a))
-> (Ptr (Bitwise a) -> Int -> Bitwise a -> IO ())
-> (forall b. Ptr b -> Int -> IO (Bitwise a))
-> (forall b. Ptr b -> Int -> Bitwise a -> IO ())
-> (Ptr (Bitwise a) -> IO (Bitwise a))
-> (Ptr (Bitwise a) -> Bitwise a -> IO ())
-> Storable (Bitwise a)
forall b. Ptr b -> Int -> IO (Bitwise a)
forall b. Ptr b -> Int -> Bitwise a -> IO ()
forall a. Storable a => Ptr (Bitwise a) -> IO (Bitwise a)
forall a. Storable a => Ptr (Bitwise a) -> Int -> IO (Bitwise a)
forall a.
Storable a =>
Ptr (Bitwise a) -> Int -> Bitwise a -> IO ()
forall a. Storable a => Ptr (Bitwise a) -> Bitwise a -> IO ()
forall a. Storable a => Bitwise a -> Int
forall a b. Storable a => Ptr b -> Int -> IO (Bitwise a)
forall a b. Storable a => Ptr b -> Int -> Bitwise a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: forall a. Storable a => Bitwise a -> Int
sizeOf :: Bitwise a -> Int
$calignment :: forall a. Storable a => Bitwise a -> Int
alignment :: Bitwise a -> Int
$cpeekElemOff :: forall a. Storable a => Ptr (Bitwise a) -> Int -> IO (Bitwise a)
peekElemOff :: Ptr (Bitwise a) -> Int -> IO (Bitwise a)
$cpokeElemOff :: forall a.
Storable a =>
Ptr (Bitwise a) -> Int -> Bitwise a -> IO ()
pokeElemOff :: Ptr (Bitwise a) -> Int -> Bitwise a -> IO ()
$cpeekByteOff :: forall a b. Storable a => Ptr b -> Int -> IO (Bitwise a)
peekByteOff :: forall b. Ptr b -> Int -> IO (Bitwise a)
$cpokeByteOff :: forall a b. Storable a => Ptr b -> Int -> Bitwise a -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Bitwise a -> IO ()
$cpeek :: forall a. Storable a => Ptr (Bitwise a) -> IO (Bitwise a)
peek :: Ptr (Bitwise a) -> IO (Bitwise a)
$cpoke :: forall a. Storable a => Ptr (Bitwise a) -> Bitwise a -> IO ()
poke :: Ptr (Bitwise a) -> Bitwise a -> IO ()
Storable, Bitwise a -> ModifierParser
Bitwise a -> FieldFormatter
(Bitwise a -> FieldFormatter)
-> (Bitwise a -> ModifierParser) -> PrintfArg (Bitwise a)
forall a. PrintfArg a => Bitwise a -> ModifierParser
forall a. PrintfArg a => Bitwise a -> FieldFormatter
forall a.
(a -> FieldFormatter) -> (a -> ModifierParser) -> PrintfArg a
$cformatArg :: forall a. PrintfArg a => Bitwise a -> FieldFormatter
formatArg :: Bitwise a -> FieldFormatter
$cparseFormat :: forall a. PrintfArg a => Bitwise a -> ModifierParser
parseFormat :: Bitwise a -> ModifierParser
PrintfArg)

instance (Num a, Bits a) => Boolean (Bitwise a) where
  true :: Bitwise a
true   = Bitwise a -> Bitwise a
forall b. Boolean b => b -> b
not Bitwise a
forall b. Boolean b => b
false
  false :: Bitwise a
false  = a -> Bitwise a
forall a. a -> Bitwise a
Bitwise a
0
  not :: Bitwise a -> Bitwise a
not    = a -> Bitwise a
forall a. a -> Bitwise a
Bitwise (a -> Bitwise a) -> (Bitwise a -> a) -> Bitwise a -> Bitwise a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
forall a. Bits a => a -> a
complement (a -> a) -> (Bitwise a -> a) -> Bitwise a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bitwise a -> a
forall a. Bitwise a -> a
getBits
  && :: Bitwise a -> Bitwise a -> Bitwise a
(&&)   = (a -> Bitwise a
forall a. a -> Bitwise a
Bitwise (a -> Bitwise a) -> (a -> a) -> a -> Bitwise a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((a -> a) -> a -> Bitwise a)
-> (a -> a -> a) -> a -> a -> Bitwise a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a
forall a. Bits a => a -> a -> a
(.&.) (a -> a -> Bitwise a)
-> (Bitwise a -> a) -> Bitwise a -> Bitwise a -> Bitwise a
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Bitwise a -> a
forall a. Bitwise a -> a
getBits
  || :: Bitwise a -> Bitwise a -> Bitwise a
(||)   = (a -> Bitwise a
forall a. a -> Bitwise a
Bitwise (a -> Bitwise a) -> (a -> a) -> a -> Bitwise a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((a -> a) -> a -> Bitwise a)
-> (a -> a -> a) -> a -> a -> Bitwise a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a
forall a. Bits a => a -> a -> a
(.|.) (a -> a -> Bitwise a)
-> (Bitwise a -> a) -> Bitwise a -> Bitwise a -> Bitwise a
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Bitwise a -> a
forall a. Bitwise a -> a
getBits
  xor :: Bitwise a -> Bitwise a -> Bitwise a
xor    = (a -> Bitwise a
forall a. a -> Bitwise a
Bitwise (a -> Bitwise a) -> (Bitwise a -> a) -> Bitwise a -> Bitwise a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Bitwise a -> a) -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a -> a)
-> Bitwise a
-> Bitwise a
-> Bitwise a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> a
forall a. Bits a => a -> a -> a
Bits.xor (a -> a -> a) -> (Bitwise a -> a) -> Bitwise a -> Bitwise a -> a
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Bitwise a -> a
forall a. Bitwise a -> a
getBits)
  <--> :: Bitwise a -> Bitwise a -> Bitwise a
(<-->) = Bitwise a -> Bitwise a -> Bitwise a
forall b. Boolean b => b -> b -> b
xor (Bitwise a -> Bitwise a -> Bitwise a)
-> (Bitwise a -> Bitwise a) -> Bitwise a -> Bitwise a -> Bitwise a
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Bitwise a -> Bitwise a
forall b. Boolean b => b -> b
not