从列表元组列表中过滤元组

Question

I have a tuple nested inside of two lists and I'm trying to filter the tuples depending if they're consistent or not.

I need to check the first element of the tuples and any that match should have the same Bool. Otherwise it should be removed from the List. My input looks something like this.

[[('a',True),('a',False),('b',True),('c',False),('a',False)], [('a',True),('a',True),('b',True),('b',False)]]

and I'm trying to achieve:

[[('b',True),('c',False),], [('a',True),('a',True)]]

'a's where removed from the first List as both True and False was tied to 'a', then the 'b's were removed from the second List as again both True and False was tied to 'b'.

I thought by breaking the task up into seperate functions it would make it easier. So I created this mapTuples functions to create a list of tuples that have the same first element.

mapTuples :: [(Char,Bool)] -> [(Char,Bool)]
mapTuples (x:y:ys) | fst(x) == fst(y) = ((y):mapTuples (x:ys))
                   | otherwise = mapTuples (x:ys)
mapTuples (x:[]) = [x]
mapTuples [] = []

From here I've made a function checkTuples, to check the Lists from the above function and see if any of the Bool's don't match. It'll return True if they all match or False if they don't.

checkTuples :: [(Char,Bool)] -> Bool
checkTuples (x:y:ys) | snd(x) /= snd(y) = False
                     | otherwise = checkTuples(x:ys)
checkTuples (x:[]) = True

Then finally I have my removeConflicts to remove any of the inconsistent Tuples. Which I'm using to loop through my Lists and Tuples.

removeConflicts :: [[(Char,Bool)]] -> [[(Char,Bool)]]
removeConflicts (x:ys) | checkTuples(mapTuples(x)) == False = removeConflicts(ys)
                       | otherwise = x:removeConflicts(ys)
removeConflicts [] = []

Which currently doesn't work as intended and I know its because of this part:

False = removeConflicts(ys)

I believe I need to somehow also include my x value that has been filtered. But I'm not sure how to go about doing so. Something like

removeConflicts (x:ys) | checkTuples(mapTuples(x)) == False = removeConflicts(filtered(x):ys)

Where filtered(x) removes unwanted Tuples.

Hope this all makes sense and sorry for long winded explanation, didn't want to leave anything out.

Answer 1

My first remark is that you've complicated this specification by talking about lists of lists of tuples. The computation you describe is to transform each list within this nested list in the same way: that's what map does. So we can reduce the problem already to

removeConflicts :: [[(Char, Bool)]] -> [[(Char, Bool)]]
removeConflicts = map processList

for some processList:: [(Char, Bool)] -> [(Char, Bool)] we must define. Let's start on that.

processList :: [(Char, Bool)] -> [(Char, Bool)]
processList [] = []
processList ((label, value):more) = _

Easy enough to process an empty list. For a non-empty list, we want to split the list into two parts: the tuples that share the same label as this, and the tuples that don't. Some Hoogling around will reveal partition is suited to this task, so:

processList :: [(Char, Bool)] -> [(Char, Bool)]
processList [] = []
processList xs@((label, value):_) =
  let (same, different) = partition ((== label) . fst) xs
  in _

Now that we have the list in these two halves, all that's left to do is (1) decide whether to keep the same chunk or discard it, and (2) call ourselves recursively on different :

processList :: [(Char, Bool)] -> [(Char, Bool)]
processList [] = []
processList xs@(x@(label, value):_) =
  let (same, different) = partition ((== label) . fst) xs
      chunk | all (== x) same = same
            | otherwise = []
  in chunk ++ processList different

Finally let's clean up by generalizing from these over-specific types to be polymorphic on Eq types:

removeConflicts :: (Eq a, Eq b) => [[(a, b)]] -> [[(a, b)]]
removeConflicts = map processList

processList :: (Eq a, Eq b) => [(a, b)] -> [(a, b)]
processList [] = []
processList xs@(x@(label, value):_) =
  let (same, different) = partition ((== label) . fst) xs
      chunk | all (== x) same = same
            | otherwise = []
  in chunk ++ processList different