Proposal: change the Bits instance for Bool to align with other basic types and support branchless calculations

[David Feuer]

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#)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/libraries/attachments/20140927/dc8ba12f/attachment.html>