Haskell - how to iterate list elements in reverse order in an elegant way?

Question

I'm trying to write a function that given a list of numbers, returns a list where every 2nd number is doubled in value, starting from the last element. So if the list elements are 1..n, n-th is going to be left as-is, (n-1)-th is going to be doubled in value, (n-2)-th is going to be left as-is, etc.

So here's how I solved it:

MyFunc :: [Integer] -> [Integer]
MyFunc xs = reverse (MyFuncHelper (reverse xs))

MyFuncHelper :: [Integer] -> [Integer]
MyFuncHelper []       = []
MyFuncHelper (x:[])   = [x]
MyFuncHelper (x:y:zs) = [x,y*2] ++ MyFuncHelper zs

And it works:

MyFunc [1,1,1,1] = [2,1,2,1]
MyFunc [1,1,1] = [1,2,1]

However, I can't help but think there has to be a simpler solution than reversing the list, processing it and then reversing it again. Could I simply iterate the list backwards? If yes, how?

Answer 1

The under reversed f xs idiom from the lens library will apply f to xs in reverse order:

under reversed (take 5) [1..100] => [96,97,98,99,100]

Answer 2

When you need to process the list from the end, usually foldr works pretty well. Here is a solution for you without reversing the whole list twice:

doubleOdd :: Num a => [a] -> [a]
doubleOdd = fst . foldr multiplyCond ([], False)
    where multiplyCond x (rest, flag) = ((if flag then (x * 2) else x) : rest, not flag)

The multiplyCond function takes a tuple with a flag and the accumulator list. The flag constantly toggles on and off to track whether we should multiply the element or not. The accumulator list simply gathers the resulting numbers. This solution may be not so concise, but avoids extra work and doesn't use anything but prelude functions.

Answer 3

myFunc = reverse
       . map (\(b,x) -> if b then x*2 else x)
       . zip (cycle [False,True])
       . reverse

But this isn't much better. Your implementation is sufficiently elegant.