Currently, the (.&.) and (.|.) methods for Bool are short-circuiting, defined like this:

instance Bits Bool where
    (.&.) = (&&)

    (.|.) = (||)

Unlike the instances for Int, Word, etc., this gives short-circuiting behavior (conditionally lazy in the second operand). Unfortunately, this requires a conditional branch to implement, which can sometimes be bad. Since (&&) and (||) are readily available to anyone who wants short-circuiting, I propose that we use the following instead. Note that the Bits class does not specify anything about this aspect of instance behavior.

  x .&. y = tagToEnum# (dataToTag# x `andI#` dataToTag# y)

  x .|. y = tagToEnum# (dataToTag# x `orI#` dataToTag# y)

The rest of the operations look like this:

    x `xor` y = tagToEnum# (dataToTag# x `xorI#` dataToTag# y)

    complement x = tagToEnum# (dataToTag# x `xorI#` 1#)

    shift x s = testBit x s

    rotate x _ = x

-- I don't think we gain anything changing this one.
    bit 0 = True
    bit _ = False

    testBit x b = tagToEnum# (dataToTag# x `andI#` (dataToTag# b ==# 0#))

    bitSizeMaybe _ = Just 1

    bitSize _ = 1

    isSigned _ = False

    popCount x = I# (dataToTag# x)

instance FiniteBits Bool where
    finiteBitSize _ = 1
    countTrailingZeros x = I# (dataToTag# x `xorI#` 1#)
    countLeadingZeros  x = I# (dataToTag# x `xorI#` 1#)