Haskell 将 Word8 转换为 Int 到 Bits

Question

I want to convert a Word8 to an Int so I can convert it to a list of Bits is there anyway to convert it to either an int or straight to bits?

This is my current snippet of a code

intsToBits :: Int -> [Bit]
intsToBits x  =
  reverse (go x) where
  go 0 = [Zero]
  go n | n `mod` 2 == 1 = One : go (n `div` 2)
       | n `mod` 2 == 0 = Zero : go (n `div` 2)
  go _ = []

word8ToInt :: Word8 -> Int
word8ToInt = fromIntegral

decoder :: BS.ByteString -> IO [Bit]
decoder raw =
  do
     let raw' = BS.unpack raw
     let ls = go raw'
     return ls
       where
         go []     = []
         go [x]    = intsToBits $  x
         go (x:xs) = intsToBits (word8ToInt x) ++ go xs

Answer 1

Word8 is an instance of the FiniteBits class, so you can use something like

toBitList x = map (testBit x) [0..(finiteBitSize x-1)]

Or if you want it the other way around, [(finiteBitSize x-1), (finiteBitSize x-2)..0] .

---

I see from your edit that you (apparently) want your bits in order from most significant to least significant, and you don't want any leading zeros. There are various ways to do this, but the easiest is probably to modify the above approach using countLeadingZeros .

Answer 2

Meta on asking questions: You really should give some examples of how you tried to solve the problem. Shy of that, at least an example of the result you want such as what "bits" means to you. I tend to think of a collection of Word8 values as bits and so there is operation to be performed.

That said, lets pose and answer a series of related questions.

What are the bit operators in Haskell?

If you want bit level operations, instead of doing arithmetic tricks like x || 2^ix || 2^i you can use the functions from the Bits class:

Prelude> import Data.Bits
Prelude Data.Bits> :i Bits
class Eq a => Bits a where
  (.&.) :: a -> a -> a
  (.|.) :: a -> a -> a
  xor :: a -> a -> a
  complement :: a -> a
  shift :: a -> Int -> a
  rotate :: a -> Int -> a
  zeroBits :: a
  bit :: Int -> a
  setBit :: a -> Int -> a
  clearBit :: a -> Int -> a
  complementBit :: a -> Int -> a
  testBit :: a -> Int -> Bool
  bitSizeMaybe :: a -> Maybe Int
  bitSize :: a -> Int
  isSigned :: a -> Bool
  shiftL :: a -> Int -> a
  unsafeShiftL :: a -> Int -> a
  shiftR :: a -> Int -> a
  unsafeShiftR :: a -> Int -> a
  rotateL :: a -> Int -> a
  rotateR :: a -> Int -> a
  popCount :: a -> Int

And also the FiniteBits class:

class Bits b => FiniteBits b where
  finiteBitSize      :: b -> Int
  countLeadingZeros  :: b -> Int
  countTrailingZeros :: b -> Int

How can I convert Word8 to [Bool] ?

This is simply testing each bit in the word, and b

toBits x = [testBit x i | i <- [0.. finiteBitSize x - 1]

How can I convert Word8 to some datatype I called Bit that I won't show you?

After your first edit I now think you have data Bit = Zero | One data Bit = Zero | One but am unclear if that's correct. It seems like homework and the advice given here should suffice to get the rest of the way either way.