    module Network.HPACK.Huffman.Bit (
        -- * Bits
        B (..),
        Bits,
        fromBits,
    ) where

    import Imports

    -- | Data type for Bit.
    data B
        = -- | Zero
          F
        | -- | One
          T
        deriving (B -> B -> Bool
    (B -> B -> Bool) -> (B -> B -> Bool) -> Eq B
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: B -> B -> Bool
    == :: B -> B -> Bool
    $c/= :: B -> B -> Bool
    /= :: B -> B -> Bool
    Eq, Eq B
    Eq B =>
    (B -> B -> Ordering)
    -> (B -> B -> Bool)
    -> (B -> B -> Bool)
    -> (B -> B -> Bool)
    -> (B -> B -> Bool)
    -> (B -> B -> B)
    -> (B -> B -> B)
    -> Ord B
    B -> B -> Bool
    B -> B -> Ordering
    B -> B -> B
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: B -> B -> Ordering
    compare :: B -> B -> Ordering
    $c< :: B -> B -> Bool
    < :: B -> B -> Bool
    $c<= :: B -> B -> Bool
    <= :: B -> B -> Bool
    $c> :: B -> B -> Bool
    > :: B -> B -> Bool
    $c>= :: B -> B -> Bool
    >= :: B -> B -> Bool
    $cmax :: B -> B -> B
    max :: B -> B -> B
    $cmin :: B -> B -> B
    min :: B -> B -> B
    Ord, Int -> B -> ShowS
    [B] -> ShowS
    B -> String
    (Int -> B -> ShowS) -> (B -> String) -> ([B] -> ShowS) -> Show B
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> B -> ShowS
    showsPrec :: Int -> B -> ShowS
    $cshow :: B -> String
    show :: B -> String
    $cshowList :: [B] -> ShowS
    showList :: [B] -> ShowS
    Show)

    -- | Bit stream.
    type Bits = [B]

    fromBit :: B -> Word8
    fromBit :: B -> Word8
    fromBit B
    F = Word8
    0
    fromBit B
    T = Word8
    1

    -- | From 'Bits' of length 8 to 'Word8'.
    --
    -- >>> fromBits [T,F,T,F,T,F,T,F]
    -- 170
    -- >>> fromBits [F,T,F,T,F,T,F,T]
    -- 85
    fromBits :: Bits -> Word8
    fromBits :: [B] -> Word8
    fromBits = (Word8 -> Word8 -> Word8) -> Word8 -> [Word8] -> Word8
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' (\Word8
    x Word8
    y -> Word8
    x Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    * Word8
    2 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    + Word8
    y) Word8
    0 ([Word8] -> Word8) -> ([B] -> [Word8]) -> [B] -> Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (B -> Word8) -> [B] -> [Word8]
    forall a b. (a -> b) -> [a] -> [b]
    map B -> Word8
    fromBit