My attempt not only compiled, but seems to run OK. (Really, a just gave it
a couple of trivial tests, and said good enough. I didn't really mess with
corner cases like empty lists. It was late, and I didn't want to tempt
fate.)
THUS,
I am mostly looking for style feedback, although if there are any obvious
logic errors, I'd be "happy" to learn about those too.
{--
7. Modify the binary string transmitter example to detect simple
transmission errors using the concept of parity bits. That is, each
eight-bit binary number produced during encoding is extended with a parity
bit, set to one if the number contains an odd number of ones, and to zero
otherwise. In turn, each resulting nine-bit binary number consumed during
decoding is checked to ensure that its parity bit is correct, with the
parity bit being discarded if this is the case, and a parity error being
reported otherwise. Hint: the library function error :: String -> a
displays the given string as an error message and terminates the program;
the polymorphic result type ensures that error can be used in any context.
8. Test your new string transmitter program from the previous exercise
using a faulty communication channel that forgets the first bit, which can
be modelled using the tail function on lists of bits.
Hutton, Graham. Programming in Haskell (Kindle Locations 2842-2851).
Cambridge University Press. Kindle Edition.
--}
import Data.Char
type Bit = Int
byte :: Int
byte = 8
parityByte :: Int
parityByte = 9
bin2int :: [Bit] -> Int
bin2int = foldr (\x y -> x + 2 * y) 0
-- Hutton, Graham. Programming in Haskell (Kindle Locations 2647-2649).
Cambridge University Press. Kindle Edition.
int2bin :: Int -> [Bit]
int2bin 0 = []
int2bin n = n `mod` 2 : int2bin (n `div` 2)
-- Hutton, Graham. Programming in Haskell (Kindle Locations 2654-2656).
Cambridge University Press. Kindle Edition.
make8 :: [Bit] -> [Bit]
make8 bits = addParity (take byte (bits ++ repeat 0))
-- Parity functions
addParity :: [Bit] -> [Bit]
addParity xs = if even (sum xs)
then xs ++ [0]
else xs ++ [1]
checkParity :: [Bit] -> Bool
checkParity xs = (((even . sum) (take ((length xs) - 1) xs)) ==
((even . last) xs)) ||
(((odd . sum) (take ((length xs) - 1) xs)) ==
((odd . last) xs))
errorParity :: [Bit] -> ([Bit], Bool)
errorParity xs = if checkParity xs
then (xs, checkParity xs)
else error "Parity error"
dropParity :: [Bit] -> [Bit]
dropParity xs = take ((length xs) - 1) xs
-- Hutton, Graham. Programming in Haskell (Kindle Locations 2662-2663).
Cambridge University Press. Kindle Edition.
-- TRANSMISSION
encode :: String -> [Bit]
encode = concat . map (make8 . int2bin . ord)
-- Hutton, Graham. Programming in Haskell (Kindle Locations 2673-2675).
Cambridge University Press. Kindle Edition.
chop8 :: [Bit] -> [[Bit]]
chop8 [] = []
chop8 bits = (dropParity . fst . errorParity) (take parityByte bits) :
chop8 (drop parityByte bits)
-- Hutton, Graham. Programming in Haskell (Kindle Locations 2681-2683).
Cambridge University Press. Kindle Edition.
decode :: [Bit] -> String
decode = map (chr . bin2int) . chop8
-- Hutton, Graham. Programming in Haskell (Kindle Locations 2686-2688).
Cambridge University Press. Kindle Edition.
-- channel :: [Bit] -> [Bit]
-- channel = id
channel :: [Bit] -> [Bit]
channel = tail
-- Hutton, Graham. Programming in Haskell (Kindle Locations 2696-2697).
Cambridge University Press. Kindle Edition.
transmit :: String -> String
transmit = decode . channel . encode
-- Hutton, Graham. Programming in Haskell (Kindle Locations 2694-2695).
Cambridge University Press. Kindle Edition.
