如何在无符号类型（例如，Word8，Word16）上使用Haskell的按位函数？

Question

What (if anything) can I do in order to be able to use functions from Data.Bits (eg, clearBit , setBit ) on unsigned types, namely Word8 and Word16 ? At the moment, I get the following error:

Couldn't match expected type ‘Int’ with actual type ‘Word8’

I'm going to be performing a large volume of these operations so fromIntegral is not ideal.

Any suggestions?

Update 2: This is what I needed:

testBitW :: (Bits a, Integral b) => a -> b -> Bool
testBitW a i = testBit a (fromIntegral i)

Update:

Am pulling my hair out trying to get the following to compile. It's puzzling that the same code works fine if entered directly into GHCi (running :t gives the same implied type signature as per my definition below).

testBitW :: (Integral a, Integral b) => a -> b -> Bool
testBitW a i = testBit (fromInteger $ toInteger a) (fromInteger $ toInteger i)

I keep getting the following two errors. Using fromIntegral in place of fromInteger $ toInteger results in the same errors...

test.hs:119:16:
    Could not deduce (Bits a0) arising from a use of ‘testBit’
    from the context (Integral a1, Integral a)
      bound by the inferred type of
               testBitW :: (Integral a1, Integral a) => a -> a1 -> Bool
      at test.hs:119:1-78
    The type variable ‘a0’ is ambiguous
    Note: there are several potential instances:
      instance Bits Word16 -- Defined in ‘GHC.Word’
      instance Bits Word32 -- Defined in ‘GHC.Word’
      instance Bits Word64 -- Defined in ‘GHC.Word’
      ...plus 9 others
    In the expression:
      testBit (fromInteger $ toInteger a) (fromInteger $ toInteger i)
    In an equation for ‘testBitW’:
        testBitW a i
          = testBit (fromInteger $ toInteger a) (fromInteger $ toInteger i)

test.hs:119:25:
    Could not deduce (Num a0) arising from a use of ‘fromInteger’
    from the context (Integral a1, Integral a)
      bound by the inferred type of
               testBitW :: (Integral a1, Integral a) => a -> a1 -> Bool
      at test.hs:119:1-78
    The type variable ‘a0’ is ambiguous
    Note: there are several potential instances:
      instance Num Double -- Defined in ‘GHC.Float’
      instance Num Float -- Defined in ‘GHC.Float’
      instance Integral a => Num (GHC.Real.Ratio a)
        -- Defined in ‘GHC.Real’
      ...plus 11 others
    In the expression: fromInteger
    In the first argument of ‘testBit’, namely
      ‘(fromInteger $ toInteger a)’
    In the expression:
      testBit (fromInteger $ toInteger a) (fromInteger $ toInteger i)
Failed, modules loaded: none.

Answer 1

Importing Data.Word will bring instances of Bits Word8 etc. into scope.

Although from your error it looks like you're talking about the second argument to eg setBit , which is specified to be Int . If you want to specify the bit offset with Word s, you'll have to use fromInteger . toInteger fromInteger . toInteger . You can probably abstract it out somehow, depending on the context.

Update

The errors of the form "could not deduce..." are, in this case, strong hints from the compiler about the needed type signature. Here's how to work it out.

First, what's the type of testBit ?

> :t testBit
testBit :: Bits a => a -> Int -> Bool

So we know the second argument needs to be an Int (not an Integer !), but the first argument can be any type with a Bits instance. The most general conversion to an Int is via Integer :

> :t \x -> (fromInteger . toInteger $ x) :: Int
\x -> (fromInteger . toInteger $ x) :: Int
  :: Integral s => s -> Int

Therefore we need to know one thing about each parameter to our testBitW function: the first needs to be an instance of Bits , and the second an instance of Integral . (We don't need to convert the first parameter to an Int , and in fact doing so is almost certainly an error.)

When in doubt, we can let the compiler infer the constraints, which will usually give you the most general type signature:

> let testBitW a i = testBit a (fromInteger . toInteger $ i)
> :t testBitW
testBitW :: (Bits a, Integral s) => a -> s -> Bool

And that's the type signature to put in your source file.

Answer 2

The reason that the second code snippet doesn't work is that you don't have (... Bits a, Bits b) => as part of the constraint. Integral doesn't imply Bits . In that case, you also don't need to convert the first argument at all and you just need fromIntegral for the second argument (like your first code snippet).

testBit requires its first argument to be of a type that is an instance of Bits , and you can't determine that from Integral constraints since those two type classes are essentially independent of each other.

Also, I suspect those fromIntegral calls will have minimal run time cost.

Incidentally, fromIntegral is defined as :

fromIntegral :: (Integral a, Num b) => a -> b
fromIntegral = fromInteger . toInteger

Although, there are RULES that optimize that definition out some common cases and there are more fromIntegral RULES for these particular cases in GHC.Word (which is imported by Data.Word ).

I believe the reason that the code works in GHCi is this part (fromInteger $ toInteger a) defaulted to a more specific type. GHCi has more aggressive type defaulting than GHC (especially for numeric types like these). If I disable the numeric defaulting in GHCi with default () and then try to define testBitW as you have it in the second example, it looks like it gives the same error.