Обрабатывать список Haskell справа налево, сохраняя исходный порядок

Это можно эффективно сделать с помощью сгиба влево:

inc :: Num a => [a] -> [a]
inc xs = foldl go (\_ _ acc -> acc) xs id (+ 1) []
    where go run x f g acc = run g f (f x: acc)

Обратите внимание, что даже если это свёртка слева, список строится с использованием оператора cons (:); и он будет выполняться линейно, а не квадратично (аналогичная конструкция, как в списках различий).

\> inc [1, 2, 3]
[1,3,3]
\> inc [1, 2, 3, 4]
[2,2,4,4]

Его также можно обобщить на чередование функций, отличных от id и (+ 1).

Типичным способом обработки списка Haskell справа налево было бы перевернуть его. Поскольку вы хотите получить первоначальный порядок результата, вы просто снова отмените его:

f1 = reverse . zipWith (+) (cycle [0,1]) . reverse

Но если вы действительно этого хотите, вы можете сделать так, чтобы каждый рекурсивный вызов возвращал как обновленный хвост, так и флаг, указывающий, является ли эта позиция четной, если считать с конца, чтобы вы знали, увеличивать ли элемент в этой позиции или нет:

f2 = snd . g
  where
  g []     = (False, [])
  g (x:xs) = let (addOne, xs') = g xs
                 x' = if addOne then x + 1 else x
             in (not addOne, x':xs')

По сути, мы сопоставляем функцию со списком, но для этой функции требуется дополнительный параметр, который вычисляется, начиная с правого конца списка. Есть стандартная функция, которую мы можем использовать:

import Data.List (mapAccumR)
f2' = snd . mapAccumR g False
  where
  g addOne x = (not addOne, if addOne then x + 1 else x)

Я думаю, что более точная спецификация того, что вы хотите, заключается в том, что вы увеличиваете четные индексы, если длина четная, и нечетные индексы, если длина нечетная. Например, при индексации с нуля список длины 3 привел к увеличению индекса 1. Один из способов сделать это — использовать очевидное двухпроходное решение:

f xs = zipWith (+) (cycle sol) xs
 where sol = map fromEnum [even len, odd len] 
       len = length xs

Это можно сделать за один проход (не полагаясь на правила слияния компилятора), "завязав узел". Например (использование ручного рекурсивного стиля в качестве средства связи).

f2 xs = let (isEven, result) = go isEven xs in result
 where
  go _ []     = (True,     [])
  go e (x:xs) = let (ne,rest) = go (not e) xs
                in (not ne, x+fromEnum e : rest)

Мне нравится решение Томаса. Однако я думаю, что здесь достаточно простого foldr.

process = snd . foldr (\x (b,xs) -> (not b, x + fromEnum b:xs)) (False,[])