1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE Trustworthy #-}
-----------------------------------------------------------------------------
-- |
-- Module : Data.Bits
-- Copyright : (c) The University of Glasgow 2001
-- License : BSD-style (see the file libraries/base/LICENSE)
--
-- Maintainer : libraries@haskell.org
-- Stability : experimental
-- Portability : portable
--
-- This module defines bitwise operations for signed and unsigned
-- integers. Instances of the class 'Bits' for the 'Int' and
-- 'Integer' types are available from this module, and instances for
-- explicitly sized integral types are available from the
-- "Data.Int" and "Data.Word" modules.
--
-----------------------------------------------------------------------------
module Data.Bits (
Bits(
(.&.), (.|.), xor,
complement,
shift,
rotate,
zeroBits,
bit,
setBit,
clearBit,
complementBit,
testBit,
bitSizeMaybe,
bitSize,
isSigned,
shiftL, shiftR,
unsafeShiftL, unsafeShiftR,
rotateL, rotateR,
popCount
),
FiniteBits(
finiteBitSize,
countLeadingZeros,
countTrailingZeros
),
bitDefault,
testBitDefault,
popCountDefault,
toIntegralSized,
oneBits,
And(..), Ior(..), Xor(..), Iff(..)
) where
import GHC.Base
import GHC.Bits
import GHC.Enum
import GHC.Read
import GHC.Show
-- | A more concise version of 'complement zeroBits'.
--
-- >>> complement zeroBits :: Word == oneBits :: Word
-- True
--
-- >>> complement oneBits :: Word == zeroBits :: Word
-- True
--
-- @since 4.16
oneBits :: (Bits a) => a
oneBits = complement zeroBits
{-# INLINE oneBits #-}
-- | Monoid under bitwise AND.
--
-- >>> getAnd (And 0xab <> And 0x12) :: Word8
-- 2
--
-- @since 4.16
newtype And a = And { getAnd :: a }
deriving newtype (Bounded, Enum, Bits, FiniteBits, Eq)
deriving stock (Show, Read)
-- | @since 4.16
instance (Bits a) => Semigroup (And a) where
And x <> And y = And (x .&. y)
-- | @since 4.16
instance (Bits a) => Monoid (And a) where
mempty = And oneBits
-- | Monoid under bitwise inclusive OR.
--
-- >>> getIor (Ior 0xab <> Ior 0x12) :: Word8
-- 187
--
-- @since 4.16
newtype Ior a = Ior { getIor :: a }
deriving newtype (Bounded, Enum, Bits, FiniteBits, Eq)
deriving stock (Show, Read)
-- | @since 4.16
instance (Bits a) => Semigroup (Ior a) where
Ior x <> Ior y = Ior (x .|. y)
-- | @since 4.16
instance (Bits a) => Monoid (Ior a) where
mempty = Ior zeroBits
-- | Monoid under bitwise XOR.
--
-- >>> getXor (Xor 0xab <> 0x12) :: Word8
-- 185
--
-- @since 4.16
newtype Xor a = Xor { getXor :: a }
deriving newtype (Bounded, Enum, Bits, FiniteBits, Eq)
deriving stock (Show, Read)
-- | @since 4.16
instance (Bits a) => Semigroup (Xor a) where
Xor x <> Xor y = Xor (x `xor` y)
-- | @since 4.16
instance (Bits a) => Monoid (Xor a) where
mempty = Xor zeroBits
-- | Monoid under bitwise \'equality\'; defined as @1@ if the corresponding
-- bits match, and @0@ otherwise.
--
-- >>> getIff (Iff 0xab <> Iff 0x12) :: Word8
-- 70
--
-- @since 4.16
newtype Iff a = Iff { getIff :: a }
deriving newtype (Bounded, Enum, Bits, FiniteBits, Eq)
deriving stock (Show, Read)
-- | @since 4.16
instance (Bits a) => Semigroup (Iff a) where
Iff x <> Iff y = Iff . complement $ (x `xor` y)
-- | @since 4.16
instance (Bits a) => Monoid (Iff a) where
mempty = Iff oneBits
|
