从给定谓词的列表中配对元素

Question

I'm relatively new to Haskell and found a challenge to create a set of tuples which greedily takes from a list given a predicate. For example, using (\\x -> \\y -> odd(x+y)) on [2,3,4,5,6,7] could return [(2,3),(3,2),(4,5),(5,4),(6,7),(7,6)] or [(2,7),(6,5),(3,4),(4,3),(5,6),(7,2)] or any other valid set of pairings, as long as it's one where each pair is symmetrical, and all items from the set are included in one and only one pairing. A key part of my challenge is to learn to work with monads, specifically Maybe/Just/Nothing, so my current function is Eq a => (a -> a -> Bool) -> [a] -> Maybe [(a,a)] where Nothing is returned if a list of tuples including every element cannot be made; for example running (\\x -> \\y -> even(x+y)) on [2,3,4,5,6,7] would return Nothing , as you can't pair up all the elements to fit that predicate without leaving some out.

To start off, I thought I could generate a full list of possible pairs and filter them with the predicate. My function at present is test p xs = filter (uncurry p) [(x,y) | (x:ys) <- tails xs, y <- ys] test p xs = filter (uncurry p) [(x,y) | (x:ys) <- tails xs, y <- ys] , with the idea that later on I can remove tuples with duplicate first values (perhaps somehow using nubBy ?), run swap from Data.Tuple on what's left in my list to make my pairs symmetrical, and then run a final check to see if all the elements from the list have been included so I know whether to return nothing. I realise, however, that there's probably a better way of going about this that performs fewer redundant actions and does the final check for returning Nothing earlier on. I've tried to play around with list comprehension, but I can't come up with anything serviceable.

Answer 1

A tuple (x, y) is inherently ordered: (x, y) != (y, x) . It would be helpful to define an "unordered" pair type for filtering:

newtype Pair x = Pair { unpair :: (x, x) }

instance Eq a => Eq (Pair a) where
  (Pair p1) == (Pair p2) = p1 == p2 || p1 == swap p2

Then you can use a simpler method of generating sample pairs, using the Applicative instance for lists. You can filter out duplicates later, using Pair .

>>> (,) <$> [1, 2, 3] <*> [1, 2, 3]
[(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)]

Once you have filtered the above list, use nub by first converting all your initial results to Pair values, deduplicate using nub , then convert back to tuples:

result :: Eq x => [(x,x)] -> [(x,x)]
result = map unpair . nub . map Pair