Haskell - caesar cipher - non exhaustive pattern - list

Question

Execution of the following code results in non-exhaustive pattern error. I can't figure it out why. Please help. Thanks.
module Cipher where
import Data.Char
caesar :: Int -> [Char] -> [Char]
caesar n [] = []
caesar n st = go n st
where go nn (x:xs)
| (x:xs) == [] = []
| ((+nn) $ ord x) > 122 = (chr $ (+nn) 96) : go nn xs
| ((+nn) $ ord x) >= 97 && ((+nn) $ ord x) <=122 = (chr.(+nn) $ ord x) : go nn xs
| otherwise = error "input error"

Answer 1

I think the error lies in the following line(s)
where go nn (x:xs)
| (x:xs) == [] = []
the match (x:xs) == [] will never be true as the first one is always a list with a (real) head and a (maybe empty) tail
you can fix this by
where go _ [] = []
go nn (x:xs) | ((+nn) $ ord x) > 122 = (chr $ (+nn) 96) : go nn xs
| ((+nn) $ ord x) >= 97 && ((+nn) $ ord x) <=122 = (chr.(+nn) $ ord x) : go nn xs
| otherwise = error "input error"
Though this style is highly unreadable - i recommend changing from (+nn) $ ord x to something like ord x + nn as well as chr (ord x + nn).
Moreover you are not accounting for
whitespace in your transformation as well as
interpunction,
negative numbers and
upper case letters!
As this seems to be a homework/exercise I won't give the idiomatic solution, but only a hint that there is a function called map that you should definitely look up and use!
Also your function go is not necessary you can write the algorithm completely without it:
caesar :: Int -> String -> String
caesar _ [] = []
caesar n (x:xs)
| 122 < ord x + n = chr (96 + n) : caesar n xs
| 97 <= ord x + n && ord x + n <=122 = chr (ord x + n) : caesar n xs
| otherwise = error "input error"
Please test with "Alea, iacta esto!" and not "foo" - you'll find more bugs with the first test case.
Update:
the idiomatic way to solve a problem, where you have a list and transform every element with a function is using map, so for example
> map (\x -> x + 3) [1..3]
[4,5,6]
thus you need a function
cipher :: Int -> Char -> Char
cipher n x
| isDigit x = chr $ ord '0' + (ord x - ord '0' + n'') `mod` 10
| isLower x = chr $ ord 'a' + (ord x - ord 'a' + n' ) `mod` 26
| isUpper x = chr $ ord 'A' + (ord x - ord 'A' + n' ) `mod` 26
| otherwise = x
where n' = n `mod` 26 -- for the letters
n'' = n `mod` 10 -- for the digits
caesar :: Int -> String -> String
caesar n xs = map (cipher n) xs

Answer 2

Your go function doesn't have a case that matches an empty list. The otherwise guard doesn't help here since the pattern go nn (x:xs) doesn't match to begin with.
Try this:
caesar :: Int -> [Char] -> [Char]
caesar n [] = []
caesar n st = go n st
where go nn (x:xs)
| (x:xs) == [] = []
| ((+nn) $ ord x) > 122 = (chr $ (+nn) 96) : go nn xs
| ((+nn) $ ord x) >= 97 && ((+nn) $ ord x) <=122 = (chr.(+nn) $ ord x) : go nn xs
| otherwise = error "input error"
go _ _ = error "fix me"