based/src/Encoding/Base2.hs

-- module Encoding.Base2
--   ( enc2
--   , dec2
--   ) where

-- import Data.Char (ord, chr, digitToInt, intToDigit)

-- binaryToChar :: String -> Char
-- binaryToChar binStr = chr $ binaryToInt binStr

-- binaryToInt :: String -> Int
-- binaryToInt binStr = Prelude.foldl (\acc x -> acc * 2 + digitToInt x) 0 binStr

-- dec2 :: String -> String
-- dec2 input = map binaryToChar $ words input


-- charToBinary :: Char -> String
-- charToBinary char = let binaryStr = intToBinary $ ord char
--                     in replicate (7 - Prelude.length binaryStr) '0' ++ binaryStr

-- intToBinary :: Int -> String
-- intToBinary n = reverse $ decimalToBinary' n
--   where
--     decimalToBinary' 0 = "0"
--     decimalToBinary' m = let (q, r) = m `divMod` 2 in intToDigit r : decimalToBinary' q

-- enc2 :: String -> String
-- enc2 input = unwords $ map charToBinary input

module Encoding.Base2
  ( enc2
  , dec2
  ) where

import Data.Char (ord, chr, digitToInt, intToDigit)
import qualified Data.ByteString.Char8 as BC
import Data.ByteString (ByteString)
import qualified Data.ByteString as B

binaryToChar :: ByteString -> Char
binaryToChar binStr = chr $ binaryToInt (BC.unpack binStr)

binaryToInt :: String -> Int
binaryToInt binStr = foldl (\acc x -> acc * 2 + digitToInt x) 0 binStr

dec2 :: ByteString -> ByteString
dec2 input = BC.pack . map binaryToChar . BC.words $ input

charToBinary :: Char -> ByteString
charToBinary char = BC.pack $ replicate (7 - length binaryStr) '0' ++ binaryStr
  where
    binaryStr = intToBinary (ord char)

intToBinary :: Int -> String
intToBinary n = reverse $ decimalToBinary' n
  where
    decimalToBinary' 0 = "0"
    decimalToBinary' m = let (q, r) = m `divMod` 2 in intToDigit r : decimalToBinary' q

enc2 :: ByteString -> ByteString
enc2 input = BC.unwords . map charToBinary . BC.unpack $ input