Explaining Haskell Code [closed] - haskell

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 5 years ago.
Improve this question
I was given this code and told to explain its logic, does anyone know what is going on, new to Haskell.
cpfx :: [[Char]] -> [Char]
cpfx [] = []
cpfx [x] = x
cpfx (x:xs) = cpfx' (x:xs) 0
cpfx' :: [[Char]] -> Int -> [Char]
cpfx' [x] _ = []
cpfx' (x:xs) n
| ifMatch (x:xs) n = x!!n : cpfx' (x:xs) (n+1)
| otherwise = []
ifMatch :: [[Char]] -> Int -> Bool
ifMatch [x] _ = True
ifMatch [x,y] n = x!!n == y!!n
ifMatch (x:y:xs) n
| x!!n == y!!n = ifMatch xs n
| otherwise = False
I am having trouble understand what cpfx,cpfx' and ifMatch are doing.

Answer 1

Take each function directly and look at it. Let's start from the bottom up, since they each use each other.
ifMatch :: [[Char]] -> Int -> Bool
so ifMatch takes a list of lists of Chars (or a list of Strings) and an Int, and gives you back a true/false value. Now let's look at the pattern matches
[x] _ = True -- one element list and any number is True
[x, y] n = x!!n == y!!n {- two element list is true if the character at index
#n# is the same in both lists -}
(x:y:xs) n -- three+ element list guards against...
| x!!n == y!n -- if the characters at index #n# are equal...
= ifMatch xs n -- ... then recurse
| otherwise = False -- otherwise, give me a False.
Taken together, you can see that ifMatch is supposed to check that all strings passed to it have the same letter at index n. It is equivalent to:
ifMatch [] _ = True
ifMatch xs n = let c = head xs !! n in
foldr ((&&) . (==c) . (!!n)) True xs
Though it actually appears to have a slight bug. It only checks if each pair of strings has identical letters at index n, so
ifMatch ["This", "That", "In", "Onward"] 1 == True
-- (^ == ^) && (^ == ^)
cpfx' :: [[Char]] -> Int -> [Char]
so cpfx' takes a list of list of Chars (or a list of Strings) and an Int and gives you back a list of Chars (or a String). Let's look at pattern matches here:
cpfx' [x] _ = [] -- one element list and any number is the empty list
cpfx' (x:xs) n -- multiple element list guards against...
| ifMatch (x:xs) n -- if all #x:xs# share an element at #n#...
= x!!n : -- ...add x!!n and...
cpfx' (x:xs) (n+1) -- ...recurse to the next index
| otherwise = [] -- otherwise, empty list.
So this grabs a character from x until the characters no longer match among all the strings in x:xs, and returns that prefix string.
cpfx :: [[Char]] -> [Char]
From a list of list of Chars (or a list of Strings) to a list of Chars (or a String).
cpfx [] = [] -- empty string gives empty string
cpfx [x] = x -- one-element list gives its only element
cpfx (x:xs) = cpfx' (x:xs) 0 {- anything else gives the shared prefix starting
at index zero -}
All in all, we've got three functions that work together to give you the longest substring of the head of a list of strings that exists at the beginning of all strings in that list.
import Data.Maybe (mapMaybe)
safeIndex :: [a] -> Int -> Maybe a
safeIndex xs n | length xs > n = Just $ xs !! n
| otherwise = Nothing
allEq :: Eq a => [a] -> Bool
allEq [] = True
allEq [_] = True
allEq (x:xs) = all (==x) xs
prefix :: [String] -> String
prefix xss#(x:_) = map snd $ takeWhile pred $ zip [0..] x where
pred :: (Int, Char) -> Bool
pred (n, _) = (allEq . mapMaybe (flip safeIndex n)) xss
testData :: [String]
testData = ["Hello", "Hello, World!", "Hello, Universe!", "Hello everybody!", "Hell's to you, then!"]
main :: IO ()
main = do
let p = prefix testData
putStrLn "Should be \"Hell\""
putStrLn p
or much easier with transpose
import Data.List (transpose)
prefix' :: [String] -> String
prefix' xss#(x:_) = take (length $ takeWhile allEq transposed) x where
transposed = transpose xss
or slightly more efficient
lengthWhile :: (a -> Bool) -> [a] -> Int
lengthWhile _ [] = 0
lengthWhile pred (x:xs) | pred x = 1 + lengthWhile pred xs
| otherwise = 0
prefix'' :: [String] -> String
prefix'' xss#(x:_) = take (lengthWhile allEq transposed) x where
transposed = transpose xss