Question

Creating the permutations of a list or set is simple enough. I need to apply a function to each element of all subsets of all elements in a list, in the order in which they occur. For instance:

apply f [x,y] = { [x,y], [f x, y], [x, f y], [f x, f y] }

The code I have is a monstrous pipeline or expensive computations, and I’m not sure how to proceed, or if it’s correct. I’m sure there must be a better way to accomplish this task – perhaps in the list monad – but I’m not sure. This is my code:

apply :: Ord a => (a -> Maybe a) -> [a] -> Set [a]
apply p xs = let box = take (length xs + 1) . map (take $ length xs) in
  (Set.fromList . map (catMaybes . zipWith (flip ($)) xs) . concatMap permutations
   . box . map (flip (++) (repeat Just)) . flip iterate []) ((:) p)

The general idea was:

(1) make the list 
      [[], [f], [f,f], [f,f,f], ... ]
(2) map (++ repeat Just) over the list to obtain
      [[Just, Just, Just, Just, ... ],
       [f   , Just, Just, Just, ... ],
       [f   , f   , Just, Just, ... ],
                                ... ]
(3) find all permutations of each list in (2) shaved to the length of the input list        
(4) apply the permuted lists to the original list, garnering all possible applications
    of the function f to each (possibly empty) subset of the original list, preserving
    the original order.

I’m sure there’s a better way to do it, though. I just don’t know it. This way is expensive, messy, and rather prone to error. The Justs are there because of the intended application.

Answer 1

To do this, you can leverage the fact that lists represent non-deterministic values when using applicatives and monads. It then becomes as simple as:

apply f = mapM (\x -> [x, f x])

It basically reads as follows: “Map each item in a list to itself and the result of applying f to it. Finally, return a list of all the possible combinations of these two values across the whole list.”