List to lists of lists in recursive calling - list

Question

Here is my code:
findY mnozP a =
if null(Set.toList $ mnozP)==False
then (
if (((null(intersect ( Set.toList $ head $ Set.toList $ mnozP) (a))==False) && (null(( Set.toList $ head $ Set.toList $ mnozP) \\ (a))==False)))
then (((intersect ( Set.toList $ head $ Set.toList $ mnozP) (a)) ++ (( Set.toList $ head $ Set.toList $ mnozP) \\ (a))) ++ findY ( Set.fromList $ tail $ Set.toList $ mnozP) (a))
else findY ( Set.fromList $ tail $ Set.toList $ mnozP) (a)
)
else []
findY _ a = []
findY _ _ = []
This function checks whether is list mnozP empty, if it isn't, it takes first item and checks whether its intersection with list a is empty and its difference is not empty. In case condition is true, realizes these two operations and call it recursively again for the tail of list b.
I actually got 2 questions:
Let's assume following lists: a = ["3","4"] and mnozP = [["1","6"],["2","4","3","5"]]. The output is ["3","4","2","5"]. Is there any function which can split this list into list of lists according to every single iterations? Expected output should look like [["3","4"],["2","5"]].
While compiling GHCi says following:
Warning:
Pattern match(es) are overlapped
In an equation for `findY':
findY _ a = ...
findY _ _ = ...
I'm not sure what's wrong with my patterns. I try to cover all the possible cases which can happen. Any ideas whats wrong?
EDIT: (short summary:) The function findY should return a list of lists. Every inner list is related to one concrete iteration of recursion (in case conditions is true).

Answer 1

The function you're looking for is the list constructor. In your inductive case, you have
(((intersect ( Set.toList $ head $ Set.toList $ mnozP) (a)) ++ (( Set.toList $ head $ Set.toList $ mnozP) \\ (a))) ++ findY ( Set.fromList $ tail $ Set.toList $ mnozP) (a))
which is just
as ++ bs ++ cs
where cs is the result of the recursive call. If findY returns a list of lists, so must the whole expression. By the induction hypothesis, cs is a list of lists. In other words, the expression to the left in exp ++ cs (i.e. as ++ bs) must be a list of lists too. But it's not! intersect and \\ return flat lists, which you concatenate together, getting a new flat list.
To fix that problem you just need to wrap your left expression in a list
[as ++ bs] ++ cs
or use the list constructor
(as ++ bs) : cs
If there's anything else you could get from this, it is that you could have found that out by yourself had the code been written in a more idiomatic way. I'll try to walk you through how I "unpacked" your code.
First, I added a type signature that matched your description.
findY :: Eq a => [[a]] -> [a] -> [[a]]
Interestingly, this change alone would have pointed out the expression in the inductive case was not right.
Then, I got rid of the Set <-> [] conversions. You can either ask for your input to be sets, or just plain lists and make sure there are no duplicates. I went with the latter approach:
findY :: Eq a => [[a]] -> [a] -> [[a]]
findY mnozP a =
if null(mnozP)==False
then (
if (((null(intersect (head mnozP) (a))==False) && (null(( head mnozP) \\ (a))==False)))
then (((intersect ( head mnozP) (a)) ++ (( head mnozP) \\ (a))) ++ findY ( tail mnozP) (a))
else findY ( tail mnozP) (a)
)
else []
findY _ a = []
findY _ _ = []
It's already getting clearer. There's loads of () you can get rid of too. In Haskell, function application is just the space character. So instead of writing f(x), like you would in many languages, you write f x and surround with parentheses only to disambiguate expressions:
findY :: Eq a => [[a]] -> [a] -> [[a]]
findY mnozP a =
if (null mnozP) == False
then
if (null (intersect (head mnozP) a) == False) && (null (head mnozP \\ a) == False)
then (intersect (head mnozP) a) ++ (head mnozP \\ a) ++ findY (tail mnozP) a
else findY (tail mnozP) a
else []
findY _ a = []
findY _ _ = []
Next, notice the many repetitions of head and tail. You could bind these to variables with a let expression, but there's a better way. Haskell allows you to pattern match on the arguments in order to choose what branch should be evaluated depending on the input. Here, we only need to know if the list has a head and a tail, which happens to be exactly how you pattern match a non-empty list:
findY :: Eq a => [[a]] -> [a] -> [[a]]
findY (xs : xss) a =
if (null (intersect xs a) == False) && (null (xs \\ a) == False)
then (intersect xs a) ++ (xs \\ a) ++ findY xss a
else findY xss a
findY _ _ = []
See how doing this allowed me to get rid of the first if statement? (I also removed the extra pattern match). There is still some redundancy, let's get rid of it:
findY :: Eq a => [[a]] -> [a] -> [[a]]
findY (xs : xss) a =
let as = intersect xs a
bs = xs \\ a
in
if (null as == False) && (null bs == False)
then as ++ bs ++ findY xss a
else findY xss a
findY _ _ = []
At that point, the issue stands out.
findY :: Eq a => [[a]] -> [a] -> [[a]]
findY (xs : xss) a =
let as = intersect xs a
bs = xs \\ a
in
if (null as == False) && (null bs == False)
then (as ++ bs) : findY xss a
else findY xss a
findY _ _ = []
Now it is a matter of style, but I personally find using pattern matching is more elegant than if statements most of the time. Not so much here though:
findY :: Eq a => [[a]] -> [a] -> [[a]]
findY (xs : xss) a =
let as = intersect xs a
bs = xs \\ a
in case (as, bs) of
((_ : _), (_ : _)) -> (as ++ bs) : findY xss a
_ -> findY xss a
findY _ _ = []
but in Haskell 2010, you can use pattern guards, a more powerful version of pattern matching. It makes your code that much clearer:
findY :: Eq a => [[a]] -> [a] -> [[a]]
findY (xs : xss) a
| as#(_ : _) <- intersect xs a
, bs#(_ : _) <- xs \\ a = (as ++ bs) : findY xss a
| otherwise = findY xss a
findY _ _ = []
Finally, the shape of your program is classic structural recursion. It is usually what you would use foldr for.
findY :: Eq a => [a] -> [[a]] -> [[a]]
findY a = foldr build []
where
build xs yss
| as#(_ : _) <- intersect xs a
, bs#(_ : _) <- xs \\ a = (as ++ bs) : yss
| otherwise = yss