如何返回由交替组合 Haskell 编程中的两个函数列表产生的函数？

Question

In my Haskell course assignment, I want to cope a challenge which is essentially to catch on how to process lists of functions. The input consists of two such lists, lets say first of them is given as [A0..AN] and second one is told to be [B0..BN]. I need to return a single function that composes functions applying them so that functions alternate as nested function arguments inside an output function. In fact, it means the output like one:

G x = A0 (B0 (A1 (B1 (A2 (B2 (...AN (BN))))))

My primary solution doesn't work, there is code I've tried to start with:

funcCarnage :: [a -> a] -> [a -> a] -> (a -> a)
funcCarnage (x:xs) (y:ys) = extraFuncCarnage xs ys x 2 where
extraFuncCarnage bs fs gs n
    | length bs == 0 && length fs == 0 = gs  
    | odd n = extraFuncCarnage (tail bs) fs (gs $ head bs) (n + 1) 
    | otherwise = extraFuncCarnage bs (tail fs) (gs $ head fs) (n + 1) 

Compilation fails with erro messages:

* Occurs check: cannot construct the infinite type: a ~ a -> a
  Expected type: a -> a
    Actual type: (a -> a) -> a -> a
* In the expression: extraFuncCarnage xs ys x 2
  In an equation for `funcCarnage':
      funcCarnage (x : xs) (y : ys)
        = extraFuncCarnage xs ys x 2
        where
            extraFuncCarnage bs fs gs n
              | length bs == 0 && length fs == 0 = gs
              | odd n = extraFuncCarnage (tail bs) fs (gs $ head bs) (n + 1)
              | otherwise = extraFuncCarnage bs (tail fs) (gs $ head fs) (n + 1)

* Occurs check: cannot construct the infinite type: t1 ~ t -> t1
  Expected type: [t] -> [t] -> t1 -> a1 -> t -> t1
    Actual type: [t] -> [t] -> (t -> t1) -> a1 -> t -> t1
* In an equation for `funcCarnage':
      funcCarnage (x : xs) (y : ys)
        = extraFuncCarnage xs ys x 2
        where
            extraFuncCarnage bs fs gs n
              | length bs == 0 && length fs == 0 = gs
              | odd n = extraFuncCarnage (tail bs) fs (gs $ head bs) (n + 1)
              | otherwise = extraFuncCarnage bs (tail fs) (gs $ head fs) (n + 1)

It's some obscure complaint, so I'm confused how to proceed with solving. How do I have to fix both type errors?

Answer 1

You can first merge the two lists and then do a right fold.

import Control.Applicative(ZipList(..))

funcCarnage fs gs = foldr (.) id list
  where
    list = concat $ getZipList $ (\x y -> [x, y]) <$> ZipList fs <*> ZipList gs 

Answer 2

The other answers discuss how to use library functions as building blocks to create your function. I think it might also be interesting to see how to write the recursion yourself; in this case it's particularly simple. I will follow luqui's excellent suggestion in the comments of first writing a function to interleave two lists, then composing all the functions in the result.

interleave :: [a] -> [a] -> [a]
interleave (x:xs) ys = x : interleave ys xs
interleave [] ys = ys

compose :: [a -> a] -> a -> a
compose [] = id
compose (f:fs) = f . compose fs

Then your function can run these two in sequence:

carnage :: [a -> a] -> [a -> a] -> a -> a
carnage fs gs = compose (interleave fs gs)

Later, as you get more advanced, you may be able to notice certain common looping structures in the above code. The compose one in particular is quite a standard "shape" of iteration: do something to combine a particular element with the result of making a recursive call. This shape is so common that we have a standard library function to encapsulate it. foldr takes the combining function (that combines a single element with the result of a recursive call) and the base case result as arguments, then does the iteration, so:

compose :: [a -> a] -> a -> a
compose = foldr (.) id

The loop in interleave is a less common shape, although it does come up occasionally in various circumstances. One way is to think about it as a zip; or, you can observe that matrix transposition is essentially an arbitrary-arity zip and reuse that operation. So:

interleave :: [a] -> [a] -> [a]
interleave xs ys = concat (transpose [xs, ys])

At this point, the function implementations for compose and interleave are so short, that you might consider inlining them if you don't find the names to be an important part of the explanatory power of the code. So:

carnage :: [a -> a] -> [a -> a] -> a -> a
-- was: carnage fs gs = compose (interleave fs gs)
carnage fs gs = foldr (.) id (concat (transpose [fs, gs]))

Idiomatically, Haskell programmers typically prefer function composition chains to nested parentheses:

carnage fs gs = foldr (.) id . concat . transpose $ [fs, gs]

To my experienced eye, this looks compact and readable; I would stop there.

Answer 3

I used this

funcCarnage :: [a -> a] -> [a -> a] -> (a -> a)
funcCarnage xs ys = foldl1 (.) $ zipWith (.) xs ys

Not convinced if I used the right fold.

Applying

funcCarnage [(+) 10, (*) 2] [(+) 3, (*) 5] $ 9

gives 103 .

See ZVON for some info about (.) .